/*-------------------------------------------------------------------------
 *
 * 前端代码的查询结果打印支持
 *
 * 此文件曾是psql的一部分，但现在它被分离出来以允许其他前端程序使用它。
 * 由于打印代码需要访问cancel_pressed标志以及SIGPIPE捕获和分隔符打开/关闭函数，
 * 所有这些都随之而来。
 *
 *
 * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * src/fe_utils/print.c
 *
 *-------------------------------------------------------------------------
 */
#include "postgres_fe.h"

#include <limits.h>
#include <math.h>
#include <unistd.h>

#ifndef WIN32
#include <sys/ioctl.h>			/* for ioctl() */
#endif

#ifdef HAVE_TERMIOS_H
#include <termios.h>
#endif

#include "catalog/pg_type_d.h"
#include "fe_utils/mbprint.h"
#include "fe_utils/print.h"

/*
 * 如果调用程序没有设置
 * cancel_pressed 的任何机制，它将没有效果。
 *
 * 注意：print.c 在何时检查 cancel_pressed 的一般策略是在每行输出完成时进行检查。
 */
volatile sig_atomic_t cancel_pressed = false;

static bool always_ignore_sigpipe = false;

/* 用于区域意识数字格式化的信息；由 setDecimalLocale() 设置 */
static char *decimal_point;
static int	groupdigits;
static char *thousands_sep;

static char default_footer[100];
static printTableFooter default_footer_cell = {default_footer, NULL};

/* 行样式控制结构 */
const printTextFormat pg_asciiformat =
{
	"ascii",
	{
		{"-", "+", "+", "+"},
		{"-", "+", "+", "+"},
		{"-", "+", "+", "+"},
		{"", "|", "|", "|"}
	},
	"|",
	"|",
	"|",
	" ",
	"+",
	" ",
	"+",
	".",
	".",
	true
};

const printTextFormat pg_asciiformat_old =
{
	"old-ascii",
	{
		{"-", "+", "+", "+"},
		{"-", "+", "+", "+"},
		{"-", "+", "+", "+"},
		{"", "|", "|", "|"}
	},
	":",
	";",
	" ",
	"+",
	" ",
	" ",
	" ",
	" ",
	" ",
	false
};

/* 默认 Unicode 行样式格式 */
printTextFormat pg_utf8format;

typedef struct unicodeStyleRowFormat
{
	const char *horizontal;
	const char *vertical_and_right[2];
	const char *vertical_and_left[2];
} unicodeStyleRowFormat;

typedef struct unicodeStyleColumnFormat
{
	const char *vertical;
	const char *vertical_and_horizontal[2];
	const char *up_and_horizontal[2];
	const char *down_and_horizontal[2];
} unicodeStyleColumnFormat;

typedef struct unicodeStyleBorderFormat
{
	const char *up_and_right;
	const char *vertical;
	const char *down_and_right;
	const char *horizontal;
	const char *down_and_left;
	const char *left_and_right;
} unicodeStyleBorderFormat;

typedef struct unicodeStyleFormat
{
	unicodeStyleRowFormat row_style[2];
	unicodeStyleColumnFormat column_style[2];
	unicodeStyleBorderFormat border_style[2];
	const char *header_nl_left;
	const char *header_nl_right;
	const char *nl_left;
	const char *nl_right;
	const char *wrap_left;
	const char *wrap_right;
	bool		wrap_right_border;
} unicodeStyleFormat;

static const unicodeStyleFormat unicode_style = {
	{
		{
			/* U+2500 Box Drawings Light Horizontal */
			"\342\224\200",

			/*--
			 * U+251C Box Drawings Light Vertical and Right,
			 * U+255F Box Drawings Vertical Double and Right Single
			 *--
			 */
			{"\342\224\234", "\342\225\237"},

			/*--
			 * U+2524 Box Drawings Light Vertical and Left,
			 * U+2562 Box Drawings Vertical Double and Left Single
			 *--
			 */
			{"\342\224\244", "\342\225\242"},
		},
		{
			/* U+2550 Box Drawings Double Horizontal */
			"\342\225\220",

			/*--
			 * U+255E Box Drawings Vertical Single and Right Double,
			 * U+2560 Box Drawings Double Vertical and Right
			 *--
			 */
			{"\342\225\236", "\342\225\240"},

			/*--
			 * U+2561 Box Drawings Vertical Single and Left Double,
			 * U+2563 Box Drawings Double Vertical and Left
			 *--
			 */
			{"\342\225\241", "\342\225\243"},
		},
	},
	{
		{
			/* U+2502 Box Drawings Light Vertical */
			"\342\224\202",

			/*--
			 * U+253C Box Drawings Light Vertical and Horizontal,
			 * U+256A Box Drawings Vertical Single and Horizontal Double
			 *--
			 */
			{"\342\224\274", "\342\225\252"},

			/*--
			 * U+2534 Box Drawings Light Up and Horizontal,
			 * U+2567 Box Drawings Up Single and Horizontal Double
			 *--
			 */
			{"\342\224\264", "\342\225\247"},

			/*--
			 * U+252C Box Drawings Light Down and Horizontal,
			 * U+2564 Box Drawings Down Single and Horizontal Double
			 *--
			 */
			{"\342\224\254", "\342\225\244"},
		},
		{
			/* U+2551 Box Drawings Double Vertical */
			"\342\225\221",

			/*--
			 * U+256B Box Drawings Vertical Double and Horizontal Single,
			 * U+256C Box Drawings Double Vertical and Horizontal
			 *--
			 */
			{"\342\225\253", "\342\225\254"},

			/*--
			 * U+2568 Box Drawings Up Double and Horizontal Single,
			 * U+2569 Box Drawings Double Up and Horizontal
			 *--
			 */
			{"\342\225\250", "\342\225\251"},

			/*--
			 * U+2565 Box Drawings Down Double and Horizontal Single,
			 * U+2566 Box Drawings Double Down and Horizontal
			 *--
			 */
			{"\342\225\245", "\342\225\246"},
		},
	},
	{
		/*--
		 * U+2514 Box Drawings Light Up and Right,
		 * U+2502 Box Drawings Light Vertical,
		 * U+250C Box Drawings Light Down and Right,
		 * U+2500 Box Drawings Light Horizontal,
		 * U+2510 Box Drawings Light Down and Left,
		 * U+2518 Box Drawings Light Up and Left
		 *--
		 */
		{"\342\224\224", "\342\224\202", "\342\224\214", "\342\224\200", "\342\224\220", "\342\224\230"},

		/*--
		 * U+255A Box Drawings Double Up and Right,
		 * U+2551 Box Drawings Double Vertical,
		 * U+2554 Box Drawings Double Down and Right,
		 * U+2550 Box Drawings Double Horizontal,
		 * U+2557 Box Drawings Double Down and Left,
		 * U+255D Box Drawings Double Up and Left
		 *--
		 */
		{"\342\225\232", "\342\225\221", "\342\225\224", "\342\225\220", "\342\225\227", "\342\225\235"},
	},
	" ",
	/* U+21B5 向下箭头带转角向左 */
	"\342\206\265",
	" ",
	/* U+21B5 向下箭头带转角向左 */
	"\342\206\265",
	/* U+2026 横向省略号 */
	"\342\200\246",
	"\342\200\246",
	true
};


/* 本地函数 */
static int	fc_strlen_max_width(unsigned char *fc_str, int *fc_target_width, int fc_encoding);
static void fc_IsPagerNeeded(const printTableContent *fc_cont, int fc_extra_lines, bool fc_expanded,
						  FILE **fc_fout, bool *fc_is_pager);

static void fc_print_aligned_vertical(const printTableContent *fc_cont,
								   FILE *fc_fout, bool fc_is_pager);


/* 计算数字整数部分的位数 */
static int fc_integer_digits(const char *fc_my_str)
{
	/* 忽略任何符号... */
	if (fc_my_str[0] == '-' || fc_my_str[0] == '+')
		fc_my_str++;
	/* ... 计算初始整数位 */
	return strspn(fc_my_str, "0123456789");
}

/* 计算区域意识数字输出所需的额外长度 */
static int fc_additional_numeric_locale_len(const char *fc_my_str)
{
	int			fc_int_len = fc_integer_digits(fc_my_str),
				fc_len = 0;

	/* 计入添加的 thousands_sep 实例 */
	if (fc_int_len > groupdigits)
		fc_len += ((fc_int_len - 1) / groupdigits) * strlen(thousands_sep);

	/* 计入小数点可能增加的长度 */
	if (strchr(fc_my_str, '.') != NULL)
		fc_len += strlen(decimal_point) - 1;

	return fc_len;
}

/*
 * 根据当前的 LC_NUMERIC 语言环境设置格式化数字值
 *
 * 在新分配的块中返回适当格式化的字符串，
 * 调用者必须释放。
 *
 * 必须先调用 setDecimalLocale()。
 */
static char * fc_format_numeric_locale(const char *fc_my_str)
{
	char	   *fc_new_str;
	int			fc_new_len,
				fc_int_len,
				fc_leading_digits,
				fc_i,
				fc_new_str_pos;

	/*
	 * 如果字符串看起来不像数字，返回不变的字符串。这个
	 * 检查对于避免损坏已本地化的“货币”值至关重要。
	 */
	if (strspn(fc_my_str, "0123456789+-.eE") != strlen(fc_my_str))
		return pg_strdup(fc_my_str);

	fc_new_len = strlen(fc_my_str) + fc_additional_numeric_locale_len(fc_my_str);
	fc_new_str = pg_malloc(fc_new_len + 1);
	fc_new_str_pos = 0;
	fc_int_len = fc_integer_digits(fc_my_str);

	/* 第一组千位数的位数 */
	fc_leading_digits = fc_int_len % groupdigits;
	if (fc_leading_digits == 0)
		fc_leading_digits = groupdigits;

	/* 处理符号 */
	if (fc_my_str[0] == '-' || fc_my_str[0] == '+')
	{
		fc_new_str[fc_new_str_pos++] = fc_my_str[0];
		fc_my_str++;
	}

	/* 处理数字的整数部分 */
	for (fc_i = 0; fc_i < fc_int_len; fc_i++)
	{
		/* 该插入分隔符的时间了吗？ */
		if (fc_i > 0 && --fc_leading_digits == 0)
		{
			strcpy(&fc_new_str[fc_new_str_pos], thousands_sep);
			fc_new_str_pos += strlen(thousands_sep);
			fc_leading_digits = groupdigits;
		}
		fc_new_str[fc_new_str_pos++] = fc_my_str[fc_i];
	}

	/* 如果有，处理小数点 */
	if (fc_my_str[fc_i] == '.')
	{
		strcpy(&fc_new_str[fc_new_str_pos], decimal_point);
		fc_new_str_pos += strlen(decimal_point);
		fc_i++;
	}

	/* 复制其余部分（小数位和/或指数，以及 \0 终止符） */
	strcpy(&fc_new_str[fc_new_str_pos], &fc_my_str[fc_i]);

	/* 确认我们没有低估 new_len（高估是可以的） */
	Assert(strlen(fc_new_str) <= fc_new_len);

	return fc_new_str;
}


static void fc_print_separator(struct separator fc_sep, FILE *fc_fout)
{
	if (fc_sep.separator_zero)
		fputc('\000', fc_fout);
	else if (fc_sep.separator)
		fputs(fc_sep.separator, fc_fout);
}


/*
 * 返回明确请求的页脚列表，或者在适用时返回
 * 默认的 "(xx rows)" 页脚。当给定
 * 非默认页脚、"\pset footer off" 或特定指令时，始终省略默认页脚。
 * 竖格式为每行编号，使默认页脚多余；它们不会调用这个函数。
 *
 * 返回值可能指向静态存储；不要在调用之间保留它。
 */
static printTableFooter *
fc_footers_with_default(const printTableContent *fc_cont)
{
	if (fc_cont->footers == NULL && fc_cont->opt->default_footer)
	{
		unsigned long fc_total_records;

		fc_total_records = fc_cont->opt->prior_records + fc_cont->nrows;
		snprintf(default_footer, sizeof(default_footer),
				 ngettext("(%lu row)", "(%lu rows)", fc_total_records),
				 fc_total_records);

		return &default_footer_cell;
	}
	else
		return fc_cont->footers;
}


/*************************/
/* 未对齐的文本		 */
/*************************/


static void fc_print_unaligned_text(const printTableContent *fc_cont, FILE *fc_fout)
{
	bool		fc_opt_tuples_only = fc_cont->opt->tuples_only;
	unsigned int fc_i;
	const char *const *fc_ptr;
	bool		fc_need_recordsep = false;

	if (cancel_pressed)
		return;

	if (fc_cont->opt->start_table)
	{
		/* 打印标题 */
		if (!fc_opt_tuples_only && fc_cont->title)
		{
			fputs(fc_cont->title, fc_fout);
			fc_print_separator(fc_cont->opt->recordSep, fc_fout);
		}

		/* 打印标题行 */
		if (!fc_opt_tuples_only)
		{
			for (fc_ptr = fc_cont->headers; *fc_ptr; fc_ptr++)
			{
				if (fc_ptr != fc_cont->headers)
					fc_print_separator(fc_cont->opt->fieldSep, fc_fout);
				fputs(*fc_ptr, fc_fout);
			}
			fc_need_recordsep = true;
		}
	}
	else
		/* 假设继续打印 */
		fc_need_recordsep = true;

	/* 打印单元格 */
	for (fc_i = 0, fc_ptr = fc_cont->cells; *fc_ptr; fc_i++, fc_ptr++)
	{
		if (fc_need_recordsep)
		{
			fc_print_separator(fc_cont->opt->recordSep, fc_fout);
			fc_need_recordsep = false;
			if (cancel_pressed)
				break;
		}
		fputs(*fc_ptr, fc_fout);

		if ((fc_i + 1) % fc_cont->ncolumns)
			fc_print_separator(fc_cont->opt->fieldSep, fc_fout);
		else
			fc_need_recordsep = true;
	}

	/* 打印页脚 */
	if (fc_cont->opt->stop_table)
	{
		printTableFooter *fc_footers = fc_footers_with_default(fc_cont);

		if (!fc_opt_tuples_only && fc_footers != NULL && !cancel_pressed)
		{
			printTableFooter *fc_f;

			for (fc_f = fc_footers; fc_f; fc_f = fc_f->next)
			{
				if (fc_need_recordsep)
				{
					fc_print_separator(fc_cont->opt->recordSep, fc_fout);
					fc_need_recordsep = false;
				}
				fputs(fc_f->data, fc_fout);
				fc_need_recordsep = true;
			}
		}

		/*
		 * 最后一条记录以换行符结束，与设置的
		 * 记录分隔符无关。但是当记录分隔符是零字节时，我们
		 * 使用该分隔符（与 find -print0 和 xargs 兼容）。
		 */
		if (fc_need_recordsep)
		{
			if (fc_cont->opt->recordSep.separator_zero)
				fc_print_separator(fc_cont->opt->recordSep, fc_fout);
			else
				fputc('\n', fc_fout);
		}
	}
}


static void fc_print_unaligned_vertical(const printTableContent *fc_cont, FILE *fc_fout)
{
	bool		fc_opt_tuples_only = fc_cont->opt->tuples_only;
	unsigned int fc_i;
	const char *const *fc_ptr;
	bool		fc_need_recordsep = false;

	if (cancel_pressed)
		return;

	if (fc_cont->opt->start_table)
	{
		/* 打印标题 */
		if (!fc_opt_tuples_only && fc_cont->title)
		{
			fputs(fc_cont->title, fc_fout);
			fc_need_recordsep = true;
		}
	}
	else
		/* 假设继续打印 */
		fc_need_recordsep = true;

	/* 打印记录 */
	for (fc_i = 0, fc_ptr = fc_cont->cells; *fc_ptr; fc_i++, fc_ptr++)
	{
		if (fc_need_recordsep)
		{
			/* 在这种模式下记录分隔符是 recordsep 的 2 次出现 */
			fc_print_separator(fc_cont->opt->recordSep, fc_fout);
			fc_print_separator(fc_cont->opt->recordSep, fc_fout);
			fc_need_recordsep = false;
			if (cancel_pressed)
				break;
		}

		fputs(fc_cont->headers[fc_i % fc_cont->ncolumns], fc_fout);
		fc_print_separator(fc_cont->opt->fieldSep, fc_fout);
		fputs(*fc_ptr, fc_fout);

		if ((fc_i + 1) % fc_cont->ncolumns)
			fc_print_separator(fc_cont->opt->recordSep, fc_fout);
		else
			fc_need_recordsep = true;
	}

	if (fc_cont->opt->stop_table)
	{
		/* 打印页脚 */
		if (!fc_opt_tuples_only && fc_cont->footers != NULL && !cancel_pressed)
		{
			printTableFooter *fc_f;

			fc_print_separator(fc_cont->opt->recordSep, fc_fout);
			for (fc_f = fc_cont->footers; fc_f; fc_f = fc_f->next)
			{
				fc_print_separator(fc_cont->opt->recordSep, fc_fout);
				fputs(fc_f->data, fc_fout);
			}
		}

		/* 见 print_unaligned_text() 上述内容 */
		if (fc_need_recordsep)
		{
			if (fc_cont->opt->recordSep.separator_zero)
				fc_print_separator(fc_cont->opt->recordSep, fc_fout);
			else
				fputc('\n', fc_fout);
		}
	}
}


/********************/
/* 对齐的文本		*/
/********************/


/* 绘制“线” */
static void fc__print_horizontal_line(const unsigned int fc_ncolumns, const unsigned int *fc_widths,
					   unsigned short fc_border, printTextRule fc_pos,
					   const printTextFormat *fc_format,
					   FILE *fc_fout)
{
	const printTextLineFormat *fc_lformat = &fc_format->lrule[fc_pos];
	unsigned int fc_i,
				fc_j;

	if (fc_border == 1)
		fputs(fc_lformat->hrule, fc_fout);
	else if (fc_border == 2)
		fprintf(fc_fout, "%s%s", fc_lformat->leftvrule, fc_lformat->hrule);

	for (fc_i = 0; fc_i < fc_ncolumns; fc_i++)
	{
		for (fc_j = 0; fc_j < fc_widths[fc_i]; fc_j++)
			fputs(fc_lformat->hrule, fc_fout);

		if (fc_i < fc_ncolumns - 1)
		{
			if (fc_border == 0)
				fputc(' ', fc_fout);
			else
				fprintf(fc_fout, "%s%s%s", fc_lformat->hrule,
						fc_lformat->midvrule, fc_lformat->hrule);
		}
	}

	if (fc_border == 2)
		fprintf(fc_fout, "%s%s", fc_lformat->hrule, fc_lformat->rightvrule);
	else if (fc_border == 1)
		fputs(fc_lformat->hrule, fc_fout);

	fputc('\n', fc_fout);
}


/*
 *	在单元格周围打印漂亮的框。
 */
static void fc_print_aligned_text(const printTableContent *fc_cont, FILE *fc_fout, bool fc_is_pager)
{
	bool		fc_opt_tuples_only = fc_cont->opt->tuples_only;
	int			fc_encoding = fc_cont->opt->encoding;
	unsigned short fc_opt_border = fc_cont->opt->border;
	const printTextFormat *fc_format = get_line_style(fc_cont->opt);
	const printTextLineFormat *fc_dformat = &fc_format->lrule[PRINT_RULE_DATA];

	unsigned int fc_col_count = 0,
				fc_cell_count = 0;

	unsigned int fc_i,
				fc_j;

	unsigned int *fc_width_header,
			   *fc_max_width,
			   *fc_width_wrap,
			   *fc_width_average;
	unsigned int *fc_max_nl_lines, /* 按换行符分隔的值 */
			   *fc_curr_nl_line,
			   *fc_max_bytes;
	unsigned char **fc_format_buf;
	unsigned int fc_width_total;
	unsigned int fc_total_header_width;
	unsigned int fc_extra_row_output_lines = 0;
	unsigned int fc_extra_output_lines = 0;

	const char *const *fc_ptr;

	struct lineptr **fc_col_lineptrs;	/* 每列的行指针指针 */

	bool	   *fc_header_done;	/* 所有标题行是否已输出？ */
	int		   *fc_bytes_output;	/* 列值输出的字节数 */
	printTextLineWrap *fc_wrap;	/* 每列的换行状态 */
	int			fc_output_columns = 0; /* 交互式控制台的宽度 */
	bool		fc_is_local_pager = false;

	if (cancel_pressed)
		return;

	if (fc_opt_border > 2)
		fc_opt_border = 2;

	if (fc_cont->ncolumns > 0)
	{
		fc_col_count = fc_cont->ncolumns;
		fc_width_header = pg_malloc0(fc_col_count * sizeof(*fc_width_header));
		fc_width_average = pg_malloc0(fc_col_count * sizeof(*fc_width_average));
		fc_max_width = pg_malloc0(fc_col_count * sizeof(*fc_max_width));
		fc_width_wrap = pg_malloc0(fc_col_count * sizeof(*fc_width_wrap));
		fc_max_nl_lines = pg_malloc0(fc_col_count * sizeof(*fc_max_nl_lines));
		fc_curr_nl_line = pg_malloc0(fc_col_count * sizeof(*fc_curr_nl_line));
		fc_col_lineptrs = pg_malloc0(fc_col_count * sizeof(*fc_col_lineptrs));
		fc_max_bytes = pg_malloc0(fc_col_count * sizeof(*fc_max_bytes));
		fc_format_buf = pg_malloc0(fc_col_count * sizeof(*fc_format_buf));
		fc_header_done = pg_malloc0(fc_col_count * sizeof(*fc_header_done));
		fc_bytes_output = pg_malloc0(fc_col_count * sizeof(*fc_bytes_output));
		fc_wrap = pg_malloc0(fc_col_count * sizeof(*fc_wrap));
	}
	else
	{
		fc_width_header = NULL;
		fc_width_average = NULL;
		fc_max_width = NULL;
		fc_width_wrap = NULL;
		fc_max_nl_lines = NULL;
		fc_curr_nl_line = NULL;
		fc_col_lineptrs = NULL;
		fc_max_bytes = NULL;
		fc_format_buf = NULL;
		fc_header_done = NULL;
		fc_bytes_output = NULL;
		fc_wrap = NULL;
	}

	/* 扫描所有列标题，找到最大宽度和最大最大_nl_lines */
	for (fc_i = 0; fc_i < fc_col_count; fc_i++)
	{
		int			fc_width,
					fc_nl_lines,
					fc_bytes_required;

		pg_wcssize((const unsigned char *) fc_cont->headers[fc_i], strlen(fc_cont->headers[fc_i]),
				   fc_encoding, &fc_width, &fc_nl_lines, &fc_bytes_required);
		if (fc_width > fc_max_width[fc_i])
			fc_max_width[fc_i] = fc_width;
		if (fc_nl_lines > fc_max_nl_lines[fc_i])
			fc_max_nl_lines[fc_i] = fc_nl_lines;
		if (fc_bytes_required > fc_max_bytes[fc_i])
			fc_max_bytes[fc_i] = fc_bytes_required;
		if (fc_nl_lines > fc_extra_row_output_lines)
			fc_extra_row_output_lines = fc_nl_lines;

		fc_width_header[fc_i] = fc_width;
	}
	/* 添加最高标题列的高度 */
	fc_extra_output_lines += fc_extra_row_output_lines;
	fc_extra_row_output_lines = 0;

	/* 扫描所有单元格，找到最大宽度，计算 cell_count */
	for (fc_i = 0, fc_ptr = fc_cont->cells; *fc_ptr; fc_ptr++, fc_i++, fc_cell_count++)
	{
		int			fc_width,
					fc_nl_lines,
					fc_bytes_required;

		pg_wcssize((const unsigned char *) *fc_ptr, strlen(*fc_ptr), fc_encoding,
				   &fc_width, &fc_nl_lines, &fc_bytes_required);

		if (fc_width > fc_max_width[fc_i % fc_col_count])
			fc_max_width[fc_i % fc_col_count] = fc_width;
		if (fc_nl_lines > fc_max_nl_lines[fc_i % fc_col_count])
			fc_max_nl_lines[fc_i % fc_col_count] = fc_nl_lines;
		if (fc_bytes_required > fc_max_bytes[fc_i % fc_col_count])
			fc_max_bytes[fc_i % fc_col_count] = fc_bytes_required;

		fc_width_average[fc_i % fc_col_count] += fc_width;
	}

	/* 如果我们有行，计算平均值 */
	if (fc_col_count != 0 && fc_cell_count != 0)
	{
		int			fc_rows = fc_cell_count / fc_col_count;

		for (fc_i = 0; fc_i < fc_col_count; fc_i++)
			fc_width_average[fc_i] /= fc_rows;
	}

	/* 根据边框样式调整总显示宽度 */
	if (fc_opt_border == 0)
		fc_width_total = fc_col_count;
	else if (fc_opt_border == 1)
		fc_width_total = fc_col_count * 3 - ((fc_col_count > 0) ? 1 : 0);
	else
		fc_width_total = fc_col_count * 3 + 1;
	fc_total_header_width = fc_width_total;

	for (fc_i = 0; fc_i < fc_col_count; fc_i++)
	{
		fc_width_total += fc_max_width[fc_i];
		fc_total_header_width += fc_width_header[fc_i];
	}

	/*
	 * 此时：max_width[] 包含每列的最大宽度，
	 * max_nl_lines[] 包含每列的最大行数，
	 * max_bytes[] 包含格式化字符串的最大存储空间，
	 * width_total 包含巨大的宽度总和。现在我们为行指针分配一些内存。
	 */
	for (fc_i = 0; fc_i < fc_col_count; fc_i++)
	{
		/* 为 ptr == NULL 数组终止添加条目 */
		fc_col_lineptrs[fc_i] = pg_malloc0((fc_max_nl_lines[fc_i] + 1) *
									 sizeof(**fc_col_lineptrs));

		fc_format_buf[fc_i] = pg_malloc(fc_max_bytes[fc_i] + 1);

		fc_col_lineptrs[fc_i]->ptr = fc_format_buf[fc_i];
	}

	/* 默认换行到全宽，即不换行 */
	for (fc_i = 0; fc_i < fc_col_count; fc_i++)
		fc_width_wrap[fc_i] = fc_max_width[fc_i];

	/*
	 * 选择目标输出宽度：\pset columns，或 $COLUMNS，或 ioctl
	 */
	if (fc_cont->opt->columns > 0)
		fc_output_columns = fc_cont->opt->columns;
	else if ((fc_fout == stdout && isatty(fileno(stdout))) || fc_is_pager)
	{
		if (fc_cont->opt->env_columns > 0)
			fc_output_columns = fc_cont->opt->env_columns;
#ifdef TIOCGWINSZ
		else
		{
			struct winsize fc_screen_size;

			if (ioctl(fileno(stdout), TIOCGWINSZ, &fc_screen_size) != -1)
				fc_output_columns = fc_screen_size.ws_col;
		}
#endif
	}

	if (fc_cont->opt->format == PRINT_WRAPPED)
	{
		/*
		 * 可选的优化换行。缩小最大/平均比高的列。
		 * 轻微偏向于较宽的列。（增加窄列适应其单元格的机会。）如果可用列为
		 * 正数...并且大于不可缩小列的宽度标题
		 */
		if (fc_output_columns > 0 && fc_output_columns >= fc_total_header_width)
		{
			/* 当仍有多余宽度时... */
			while (fc_width_total > fc_output_columns)
			{
				double		fc_max_ratio = 0;
				int			fc_worst_col = -1;

				/*
				 * 找到最大宽度与平均宽度比最高的列。
				 * 这告诉我们哪一列在缩短时会产生最少的换行值。
				 * width_wrap 初始等于 max_width。
				 */
				for (fc_i = 0; fc_i < fc_col_count; fc_i++)
				{
					if (fc_width_average[fc_i] && fc_width_wrap[fc_i] > fc_width_header[fc_i])
					{
						/* 对宽列处罚其宽度的 1% */
						double		fc_ratio;

						fc_ratio = (double) fc_width_wrap[fc_i] / fc_width_average[fc_i] +
							fc_max_width[fc_i] * 0.01;
						if (fc_ratio > fc_max_ratio)
						{
							fc_max_ratio = fc_ratio;
							fc_worst_col = fc_i;
						}
					}
				}

				/* 如果无法再压缩，则退出循环。 */
				if (fc_worst_col == -1)
					break;

				/* 将目标列的宽度减一。 */
				fc_width_wrap[fc_worst_col]--;
				fc_width_total--;
			}
		}
	}

	/*
	 * 如果在扩展自动模式下，现在已经计算出预期宽度，
	 * 如果需要，可以转到垂直模式。如果输出只有一列，
	 * 扩展格式会比常规格式宽，所以在这种情况下不要使用它。
	 */
	if (fc_cont->opt->expanded == 2 && fc_output_columns > 0 && fc_cont->ncolumns > 1 &&
		(fc_output_columns < fc_total_header_width || fc_output_columns < fc_width_total))
	{
		fc_print_aligned_vertical(fc_cont, fc_fout, fc_is_pager);
		goto cleanup;
	}

	/* 如果我们超出了显示宽度，使用分页器 */
	if (!fc_is_pager && fc_fout == stdout && fc_output_columns > 0 &&
		(fc_output_columns < fc_total_header_width || fc_output_columns < fc_width_total))
	{
		fc_fout = PageOutput(INT_MAX, fc_cont->opt);	/* 强制分页器 */
		fc_is_pager = fc_is_local_pager = true;
	}

	/* 检查新的换行或我们现在的换行是否需要分页器 */
	if (!fc_is_pager && fc_fout == stdout)
	{
		/* 扫描所有单元格，找到最大宽度，计算 cell_count */
		for (fc_i = 0, fc_ptr = fc_cont->cells; *fc_ptr; fc_ptr++, fc_cell_count++)
		{
			int			fc_width,
						fc_nl_lines,
						fc_bytes_required;

			pg_wcssize((const unsigned char *) *fc_ptr, strlen(*fc_ptr), fc_encoding,
					   &fc_width, &fc_nl_lines, &fc_bytes_required);

			/*
			 * 一行可以同时有换行和导致其
			 * 跨多行显示的新行。我们在下面检查这两种情况。
			 */
			if (fc_width > 0 && fc_width_wrap[fc_i])
			{
				unsigned int fc_extra_lines;

				/* 不要计算 nl_lines 的第一行 - 它不是“额外的” */
				fc_extra_lines = ((fc_width - 1) / fc_width_wrap[fc_i]) + fc_nl_lines - 1;
				if (fc_extra_lines > fc_extra_row_output_lines)
					fc_extra_row_output_lines = fc_extra_lines;
			}

			/* i 是当前列号：随着换行递增 */
			if (++fc_i >= fc_col_count)
			{
				fc_i = 0;
				/* 在每行的最后一列，添加最高列的高度 */
				fc_extra_output_lines += fc_extra_row_output_lines;
				fc_extra_row_output_lines = 0;
			}
		}
		fc_IsPagerNeeded(fc_cont, fc_extra_output_lines, false, &fc_fout, &fc_is_pager);
		fc_is_local_pager = fc_is_pager;
	}

	/* 该输出时间 */
	if (fc_cont->opt->start_table)
	{
		/* 打印标题 */
		if (fc_cont->title && !fc_opt_tuples_only)
		{
			int			fc_width,
						fc_height;

			pg_wcssize((const unsigned char *) fc_cont->title, strlen(fc_cont->title),
					   fc_encoding, &fc_width, &fc_height, NULL);
			if (fc_width >= fc_width_total)
				/* 对齐 */
				fprintf(fc_fout, "%s\n", fc_cont->title);
			else
				/* 居中 */
				fprintf(fc_fout, "%-*s%s\n", (fc_width_total - fc_width) / 2, "",
						fc_cont->title);
		}

		/* 打印标题行 */
		if (!fc_opt_tuples_only)
		{
			int			fc_more_col_wrapping;
			int			fc_curr_nl_line;

			if (fc_opt_border == 2)
				fc__print_horizontal_line(fc_col_count, fc_width_wrap, fc_opt_border,
									   PRINT_RULE_TOP, fc_format, fc_fout);

			for (fc_i = 0; fc_i < fc_col_count; fc_i++)
				pg_wcsformat((const unsigned char *) fc_cont->headers[fc_i],
							 strlen(fc_cont->headers[fc_i]), fc_encoding,
							 fc_col_lineptrs[fc_i], fc_max_nl_lines[fc_i]);

			fc_more_col_wrapping = fc_col_count;
			fc_curr_nl_line = 0;
			if (fc_col_count > 0)
				memset(fc_header_done, false, fc_col_count * sizeof(bool));
			while (fc_more_col_wrapping)
			{
				if (fc_opt_border == 2)
					fputs(fc_dformat->leftvrule, fc_fout);

				for (fc_i = 0; fc_i < fc_cont->ncolumns; fc_i++)
				{
					struct lineptr *fc_this_line = fc_col_lineptrs[fc_i] + fc_curr_nl_line;
					unsigned int fc_nbspace;

					if (fc_opt_border != 0 ||
						(!fc_format->wrap_right_border && fc_i > 0))
						fputs(fc_curr_nl_line ? fc_format->header_nl_left : " ",
							  fc_fout);

					if (!fc_header_done[fc_i])
					{
						fc_nbspace = fc_width_wrap[fc_i] - fc_this_line->width;

						/* 居中 */
						fprintf(fc_fout, "%-*s%s%-*s",
								fc_nbspace / 2, "", fc_this_line->ptr, (fc_nbspace + 1) / 2, "");

						if (!(fc_this_line + 1)->ptr)
						{
							fc_more_col_wrapping--;
							fc_header_done[fc_i] = 1;
						}
					}
					else
						fprintf(fc_fout, "%*s", fc_width_wrap[fc_i], "");

					if (fc_opt_border != 0 || fc_format->wrap_right_border)
						fputs(!fc_header_done[fc_i] ? fc_format->header_nl_right : " ",
							  fc_fout);

					if (fc_opt_border != 0 && fc_col_count > 0 && fc_i < fc_col_count - 1)
						fputs(fc_dformat->midvrule, fc_fout);
				}
				fc_curr_nl_line++;

				if (fc_opt_border == 2)
					fputs(fc_dformat->rightvrule, fc_fout);
				fputc('\n', fc_fout);
			}

			fc__print_horizontal_line(fc_col_count, fc_width_wrap, fc_opt_border,
								   PRINT_RULE_MIDDLE, fc_format, fc_fout);
		}
	}

	/* 打印单元格，每行一个循环 */
	for (fc_i = 0, fc_ptr = fc_cont->cells; *fc_ptr; fc_i += fc_col_count, fc_ptr += fc_col_count)
	{
		bool		fc_more_lines;

		if (cancel_pressed)
			break;

		/*
		 * 格式化每个单元格。
		 */
		for (fc_j = 0; fc_j < fc_col_count; fc_j++)
		{
			pg_wcsformat((const unsigned char *) fc_ptr[fc_j], strlen(fc_ptr[fc_j]), fc_encoding,
						 fc_col_lineptrs[fc_j], fc_max_nl_lines[fc_j]);
			fc_curr_nl_line[fc_j] = 0;
		}

		memset(fc_bytes_output, 0, fc_col_count * sizeof(int));

		/*
		 * 每次循环，通过输出一行显示行。它可以
		 * 是完整的值或部分值，如果存在嵌入的新行
		 * 或如果启用了 'format=wrapping' 模式。
		 */
		do
		{
			fc_more_lines = false;

			/* 左边框 */
			if (fc_opt_border == 2)
				fputs(fc_dformat->leftvrule, fc_fout);

			/* 对于每一列 */
			for (fc_j = 0; fc_j < fc_col_count; fc_j++)
			{
				/* 我们有一个有效的数组元素，因此索引它 */
				struct lineptr *fc_this_line = &fc_col_lineptrs[fc_j][fc_curr_nl_line[fc_j]];
				int			fc_bytes_to_output;
				int			fc_chars_to_output = fc_width_wrap[fc_j];
				bool		fc_finalspaces = (fc_opt_border == 2 ||
										   (fc_col_count > 0 && fc_j < fc_col_count - 1));

				/* 打印左侧换行或新行标记 */
				if (fc_opt_border != 0)
				{
					if (fc_wrap[fc_j] == PRINT_LINE_WRAP_WRAP)
						fputs(fc_format->wrap_left, fc_fout);
					else if (fc_wrap[fc_j] == PRINT_LINE_WRAP_NEWLINE)
						fputs(fc_format->nl_left, fc_fout);
					else
						fputc(' ', fc_fout);
				}

				if (!fc_this_line->ptr)
				{
					/* 超过换行行，因此只为其他列填充 */
					if (fc_finalspaces)
						fprintf(fc_fout, "%*s", fc_chars_to_output, "");
				}
				else
				{
					/* 获取直到 width_wrap 的字符的 strlen() */
					fc_bytes_to_output =
						fc_strlen_max_width(fc_this_line->ptr + fc_bytes_output[fc_j],
										 &fc_chars_to_output, fc_encoding);

					/*
					 * 如果我们超过了 width_wrap，则意味着单个字符的显示宽度
					 * 超过了我们的目标宽度。在这种情况下，我们必须假装只打印
					 * 目标显示宽度，并尽力而为。
					 */
					if (fc_chars_to_output > fc_width_wrap[fc_j])
						fc_chars_to_output = fc_width_wrap[fc_j];

					if (fc_cont->aligns[fc_j] == 'r') /* 右对齐单元格 */
					{
						/* 先打空格 */
						fprintf(fc_fout, "%*s", fc_width_wrap[fc_j] - fc_chars_to_output, "");
						fwrite((char *) (fc_this_line->ptr + fc_bytes_output[fc_j]),
							   1, fc_bytes_to_output, fc_fout);
					}
					else		/* 左对齐单元格 */
					{
						/* 后打空格 */
						fwrite((char *) (fc_this_line->ptr + fc_bytes_output[fc_j]),
							   1, fc_bytes_to_output, fc_fout);
					}

					fc_bytes_output[fc_j] += fc_bytes_to_output;

					/* 我们还有更多文本需要换行吗？ */
					if (*(fc_this_line->ptr + fc_bytes_output[fc_j]) != '\0')
						fc_more_lines = true;
					else
					{
						/* 跳到下一行 */
						fc_curr_nl_line[fc_j]++;
						if (fc_col_lineptrs[fc_j][fc_curr_nl_line[fc_j]].ptr != NULL)
							fc_more_lines = true;
						fc_bytes_output[fc_j] = 0;
					}
				}

				/* 确定此列的下一行的换行状态 */
				fc_wrap[fc_j] = PRINT_LINE_WRAP_NONE;
				if (fc_col_lineptrs[fc_j][fc_curr_nl_line[fc_j]].ptr != NULL)
				{
					if (fc_bytes_output[fc_j] != 0)
						fc_wrap[fc_j] = PRINT_LINE_WRAP_WRAP;
					else if (fc_curr_nl_line[fc_j] != 0)
						fc_wrap[fc_j] = PRINT_LINE_WRAP_NEWLINE;
				}

				/*
				 * 如果左对齐，必要时填充剩余空间（不是
				 * 最后一列，和/或需要换行标记）。
				 */
				if (fc_cont->aligns[fc_j] != 'r') /* 左对齐单元格 */
				{
					if (fc_finalspaces ||
						fc_wrap[fc_j] == PRINT_LINE_WRAP_WRAP ||
						fc_wrap[fc_j] == PRINT_LINE_WRAP_NEWLINE)
						fprintf(fc_fout, "%*s",
								fc_width_wrap[fc_j] - fc_chars_to_output, "");
				}

				/* 打印右侧换行或换行标记 */
				if (fc_wrap[fc_j] == PRINT_LINE_WRAP_WRAP)
					fputs(fc_format->wrap_right, fc_fout);
				else if (fc_wrap[fc_j] == PRINT_LINE_WRAP_NEWLINE)
					fputs(fc_format->nl_right, fc_fout);
				else if (fc_opt_border == 2 || (fc_col_count > 0 && fc_j < fc_col_count - 1))
					fputc(' ', fc_fout);

				/* 打印列分隔符，如果不是最后一列 */
				if (fc_opt_border != 0 && (fc_col_count > 0 && fc_j < fc_col_count - 1))
				{
					if (fc_wrap[fc_j + 1] == PRINT_LINE_WRAP_WRAP)
						fputs(fc_format->midvrule_wrap, fc_fout);
					else if (fc_wrap[fc_j + 1] == PRINT_LINE_WRAP_NEWLINE)
						fputs(fc_format->midvrule_nl, fc_fout);
					else if (fc_col_lineptrs[fc_j + 1][fc_curr_nl_line[fc_j + 1]].ptr == NULL)
						fputs(fc_format->midvrule_blank, fc_fout);
					else
						fputs(fc_dformat->midvrule, fc_fout);
				}
			}

			/* 行尾边框 */
			if (fc_opt_border == 2)
				fputs(fc_dformat->rightvrule, fc_fout);
			fputc('\n', fc_fout);
		} while (fc_more_lines);
	}

	if (fc_cont->opt->stop_table)
	{
		printTableFooter *fc_footers = fc_footers_with_default(fc_cont);

		if (fc_opt_border == 2 && !cancel_pressed)
			fc__print_horizontal_line(fc_col_count, fc_width_wrap, fc_opt_border,
								   PRINT_RULE_BOTTOM, fc_format, fc_fout);

		/* 打印页脚 */
		if (fc_footers && !fc_opt_tuples_only && !cancel_pressed)
		{
			printTableFooter *fc_f;

			for (fc_f = fc_footers; fc_f; fc_f = fc_f->next)
				fprintf(fc_fout, "%s\n", fc_f->data);
		}

		fputc('\n', fc_fout);
	}

cleanup:
	/* 清理 */
	for (fc_i = 0; fc_i < fc_col_count; fc_i++)
	{
		free(fc_col_lineptrs[fc_i]);
		free(fc_format_buf[fc_i]);
	}
	free(fc_width_header);
	free(fc_width_average);
	free(fc_max_width);
	free(fc_width_wrap);
	free(fc_max_nl_lines);
	free(fc_curr_nl_line);
	free(fc_col_lineptrs);
	free(fc_max_bytes);
	free(fc_format_buf);
	free(fc_header_done);
	free(fc_bytes_output);
	free(fc_wrap);

	if (fc_is_local_pager)
		ClosePager(fc_fout);
}


static void fc_print_aligned_vertical_line(const printTextFormat *fc_format,
							const unsigned short fc_opt_border,
							unsigned long fc_record,
							unsigned int fc_hwidth,
							unsigned int fc_dwidth,
							printTextRule fc_pos,
							FILE *fc_fout)
{
	const printTextLineFormat *fc_lformat = &fc_format->lrule[fc_pos];
	unsigned int fc_i;
	int			fc_reclen = 0;

	if (fc_opt_border == 2)
		fprintf(fc_fout, "%s%s", fc_lformat->leftvrule, fc_lformat->hrule);
	else if (fc_opt_border == 1)
		fputs(fc_lformat->hrule, fc_fout);

	if (fc_record)
	{
		if (fc_opt_border == 0)
			fc_reclen = fprintf(fc_fout, "* Record %lu", fc_record);
		else
			fc_reclen = fprintf(fc_fout, "[ RECORD %lu ]", fc_record);
	}
	if (fc_opt_border != 2)
		fc_reclen++;
	if (fc_reclen < 0)
		fc_reclen = 0;
	for (fc_i = fc_reclen; fc_i < fc_hwidth; fc_i++)
		fputs(fc_opt_border > 0 ? fc_lformat->hrule : " ", fc_fout);
	fc_reclen -= fc_hwidth;

	if (fc_opt_border > 0)
	{
		if (fc_reclen-- <= 0)
			fputs(fc_lformat->hrule, fc_fout);
		if (fc_reclen-- <= 0)
			fputs(fc_lformat->midvrule, fc_fout);
		if (fc_reclen-- <= 0)
			fputs(fc_lformat->hrule, fc_fout);
	}
	else
	{
		if (fc_reclen-- <= 0)
			fputc(' ', fc_fout);
	}
	if (fc_reclen < 0)
		fc_reclen = 0;
	for (fc_i = fc_reclen; fc_i < fc_dwidth; fc_i++)
		fputs(fc_opt_border > 0 ? fc_lformat->hrule : " ", fc_fout);
	if (fc_opt_border == 2)
		fprintf(fc_fout, "%s%s", fc_lformat->hrule, fc_lformat->rightvrule);
	fputc('\n', fc_fout);
}

static void fc_print_aligned_vertical(const printTableContent *fc_cont,
					   FILE *fc_fout, bool fc_is_pager)
{
	bool		fc_opt_tuples_only = fc_cont->opt->tuples_only;
	unsigned short fc_opt_border = fc_cont->opt->border;
	const printTextFormat *fc_format = get_line_style(fc_cont->opt);
	const printTextLineFormat *fc_dformat = &fc_format->lrule[PRINT_RULE_DATA];
	int			fc_encoding = fc_cont->opt->encoding;
	unsigned long fc_record = fc_cont->opt->prior_records + 1;
	const char *const *fc_ptr;
	unsigned int fc_i,
				fc_hwidth = 0,
				fc_dwidth = 0,
				fc_hheight = 1,
				fc_dheight = 1,
				fc_hformatsize = 0,
				fc_dformatsize = 0;
	struct lineptr *fc_hlineptr,
			   *fc_dlineptr;
	bool		fc_is_local_pager = false,
				fc_hmultiline = false,
				fc_dmultiline = false;
	int			fc_output_columns = 0; /* 交互式控制台的宽度 */

	if (cancel_pressed)
		return;

	if (fc_opt_border > 2)
		fc_opt_border = 2;

	if (fc_cont->cells[0] == NULL && fc_cont->opt->start_table &&
		fc_cont->opt->stop_table)
	{
		printTableFooter *fc_footers = fc_footers_with_default(fc_cont);

		if (!fc_opt_tuples_only && !cancel_pressed && fc_footers)
		{
			printTableFooter *fc_f;

			for (fc_f = fc_footers; fc_f; fc_f = fc_f->next)
				fprintf(fc_fout, "%s\n", fc_f->data);
		}

		fputc('\n', fc_fout);

		return;
	}

	/*
	 * 在这里处理页面器，而不是在 printTable() 中，因为我们可以
	 * 通过在扩展自动模式下的 print_aligned_text() 来到这里，因此我们必须
	 * 根据垂直输出重新计算页面器的需求。
	 */
	if (!fc_is_pager)
	{
		fc_IsPagerNeeded(fc_cont, 0, true, &fc_fout, &fc_is_pager);
		fc_is_local_pager = fc_is_pager;
	}

	/* 查找标题的最大尺寸 */
	for (fc_i = 0; fc_i < fc_cont->ncolumns; fc_i++)
	{
		int			fc_width,
					fc_height,
					fc_fs;

		pg_wcssize((const unsigned char *) fc_cont->headers[fc_i], strlen(fc_cont->headers[fc_i]),
				   fc_encoding, &fc_width, &fc_height, &fc_fs);
		if (fc_width > fc_hwidth)
			fc_hwidth = fc_width;
		if (fc_height > fc_hheight)
		{
			fc_hheight = fc_height;
			fc_hmultiline = true;
		}
		if (fc_fs > fc_hformatsize)
			fc_hformatsize = fc_fs;
	}

	/* 查找最长的数据单元 */
	for (fc_i = 0, fc_ptr = fc_cont->cells; *fc_ptr; fc_ptr++, fc_i++)
	{
		int			fc_width,
					fc_height,
					fc_fs;

		pg_wcssize((const unsigned char *) *fc_ptr, strlen(*fc_ptr), fc_encoding,
				   &fc_width, &fc_height, &fc_fs);
		if (fc_width > fc_dwidth)
			fc_dwidth = fc_width;
		if (fc_height > fc_dheight)
		{
			fc_dheight = fc_height;
			fc_dmultiline = true;
		}
		if (fc_fs > fc_dformatsize)
			fc_dformatsize = fc_fs;
	}

	/*
	 * 现在我们有了设置格式
	 * 结构所需的所有信息
	 */
	fc_dlineptr = pg_malloc((sizeof(*fc_dlineptr)) * (fc_dheight + 1));
	fc_hlineptr = pg_malloc((sizeof(*fc_hlineptr)) * (fc_hheight + 1));

	fc_dlineptr->ptr = pg_malloc(fc_dformatsize);
	fc_hlineptr->ptr = pg_malloc(fc_hformatsize);

	if (fc_cont->opt->start_table)
	{
		/* 打印标题 */
		if (!fc_opt_tuples_only && fc_cont->title)
			fprintf(fc_fout, "%s\n", fc_cont->title);
	}

	/*
	 * 选择目标输出宽度：\pset columns，或 $COLUMNS，或 ioctl
	 */
	if (fc_cont->opt->columns > 0)
		fc_output_columns = fc_cont->opt->columns;
	else if ((fc_fout == stdout && isatty(fileno(stdout))) || fc_is_pager)
	{
		if (fc_cont->opt->env_columns > 0)
			fc_output_columns = fc_cont->opt->env_columns;
#ifdef TIOCGWINSZ
		else
		{
			struct winsize fc_screen_size;

			if (ioctl(fileno(stdout), TIOCGWINSZ, &fc_screen_size) != -1)
				fc_output_columns = fc_screen_size.ws_col;
		}
#endif
	}

	/*
	 * 计算换行模式下数据的可用宽度
	 */
	if (fc_cont->opt->format == PRINT_WRAPPED)
	{
		unsigned int fc_swidth,
					fc_rwidth = 0,
					fc_newdwidth;

		if (fc_opt_border == 0)
		{
			/*
			 * 对于 border = 0，中间一个空格。 （如果我们发现需要换行，
			 * 空间单元将被换行标记替换，我们将在
			 * 行末为另一个换行标记留出空间。但现在假设不需要换行。）
			 */
			fc_swidth = 1;

			/* 我们可能还需要一列用于标题换行标记 */
			if (fc_hmultiline)
				fc_swidth++;
		}
		else if (fc_opt_border == 1)
		{
			/*
			 * 对于 border = 1，中间两个空格和一个 vrule。 （如
			 * 上所述，我们可能还需要一列用于换行标记。）
			 */
			fc_swidth = 3;

			/* 我们可能还需要一列用于左侧标题换行标记 */
			if (fc_hmultiline && (fc_format == &pg_asciiformat_old))
				fc_swidth++;
		}
		else
		{
			/*
			 * 对于 border = 2，行首和行末各多两个 vrule，
			 * 加上与之相邻的空间列。 （我们
			 * 不需要额外的列用于换行/换行标记，我们只需
			 * 重新利用空间列。）
			 */
			fc_swidth = 7;
		}

		/* 如果需要，也为数据换行指示器预留一列 */
		if (fc_dmultiline &&
			fc_opt_border < 2 && fc_format != &pg_asciiformat_old)
			fc_swidth++;

		/* 确定记录标题行所需的宽度 */
		if (!fc_opt_tuples_only)
		{
			if (fc_cont->nrows > 0)
				fc_rwidth = 1 + (int) log10(fc_cont->nrows);
			if (fc_opt_border == 0)
				fc_rwidth += 9;	/* "* RECORD " */
			else if (fc_opt_border == 1)
				fc_rwidth += 12;	/* "-[ RECORD  ]" */
			else
				fc_rwidth += 15;	/* "+-[ RECORD  ]-+" */
		}

		/* 我们可能需要进行其余计算两次 */
		for (;;)
		{
			unsigned int fc_width;

			/* 不换行数据所需的总宽度 */
			fc_width = fc_hwidth + fc_swidth + fc_dwidth;
			/* ... 也不包括标题行 */
			if (fc_width < fc_rwidth)
				fc_width = fc_rwidth;

			if (fc_output_columns > 0)
			{
				unsigned int fc_min_width;

				/* 最小可接受宽度：仅容纳 3 列数据 */
				fc_min_width = fc_hwidth + fc_swidth + 3;
				/* ... 但不低于记录标题行所需的宽度 */
				if (fc_min_width < fc_rwidth)
					fc_min_width = fc_rwidth;

				if (fc_output_columns >= fc_width)
				{
					/* 空间充足，使用原生数据宽度 */
					/* （但至少足够记录标题行使用） */
					fc_newdwidth = fc_width - fc_hwidth - fc_swidth;
				}
				else if (fc_output_columns < fc_min_width)
				{
					/* 将数据宽度设置为匹配 min_width */
					fc_newdwidth = fc_min_width - fc_hwidth - fc_swidth;
				}
				else
				{
					/* 将数据宽度设置为匹配 output_columns */
					fc_newdwidth = fc_output_columns - fc_hwidth - fc_swidth;
				}
			}
			else
			{
				/* 不知道换行限制，所以使用本地数据宽度 */
				/* （但至少足够记录标题行使用） */
				fc_newdwidth = fc_width - fc_hwidth - fc_swidth;
			}

			/*
			 * 如果我们需要换行数据，但还没有分配数据
			 * 换行/换行标记列，进行分配并重新计算。
			 */
			if (fc_newdwidth < fc_dwidth && !fc_dmultiline &&
				fc_opt_border < 2 && fc_format != &pg_asciiformat_old)
			{
				fc_dmultiline = true;
				fc_swidth++;
			}
			else
				break;
		}

		fc_dwidth = fc_newdwidth;
	}

	/* 打印记录 */
	for (fc_i = 0, fc_ptr = fc_cont->cells; *fc_ptr; fc_i++, fc_ptr++)
	{
		printTextRule fc_pos;
		int			fc_dline,
					fc_hline,
					fc_dcomplete,
					fc_hcomplete,
					fc_offset,
					fc_chars_to_output;

		if (cancel_pressed)
			break;

		if (fc_i == 0)
			fc_pos = PRINT_RULE_TOP;
		else
			fc_pos = PRINT_RULE_MIDDLE;

		/* 在每个记录上方打印记录头（例如：“[ RECORD N ]”） */
		if (fc_i % fc_cont->ncolumns == 0)
		{
			unsigned int fc_lhwidth = fc_hwidth;

			if ((fc_opt_border < 2) &&
				(fc_hmultiline) &&
				(fc_format == &pg_asciiformat_old))
				fc_lhwidth++;		/* 用于换行指示符 */

			if (!fc_opt_tuples_only)
				fc_print_aligned_vertical_line(fc_format, fc_opt_border, fc_record++,
											fc_lhwidth, fc_dwidth, fc_pos, fc_fout);
			else if (fc_i != 0 || !fc_cont->opt->start_table || fc_opt_border == 2)
				fc_print_aligned_vertical_line(fc_format, fc_opt_border, 0, fc_lhwidth,
											fc_dwidth, fc_pos, fc_fout);
		}

		/* 格式化头部 */
		pg_wcsformat((const unsigned char *) fc_cont->headers[fc_i % fc_cont->ncolumns],
					 strlen(fc_cont->headers[fc_i % fc_cont->ncolumns]),
					 fc_encoding, fc_hlineptr, fc_hheight);
		/* 格式化数据 */
		pg_wcsformat((const unsigned char *) *fc_ptr, strlen(*fc_ptr), fc_encoding,
					 fc_dlineptr, fc_dheight);

		/*
		 * 并行遍历头部和数据，处理换行和
		 * 换行直到它们都耗尽
		 */
		fc_dline = fc_hline = 0;
		fc_dcomplete = fc_hcomplete = 0;
		fc_offset = 0;
		fc_chars_to_output = fc_dlineptr[fc_dline].width;
		while (!fc_dcomplete || !fc_hcomplete)
		{
			/* 左边界 */
			if (fc_opt_border == 2)
				fprintf(fc_fout, "%s", fc_dformat->leftvrule);

			/* 头部（永不换行，因此只需处理换行） */
			if (!fc_hcomplete)
			{
				int			fc_swidth = fc_hwidth,
							fc_target_width = fc_hwidth;

				/*
				 * 左侧填充或换行指示符
				 */
				if ((fc_opt_border == 2) ||
					(fc_hmultiline && (fc_format == &pg_asciiformat_old)))
					fputs(fc_hline ? fc_format->header_nl_left : " ", fc_fout);

				/*
				 * 头部文本
				 */
				fc_strlen_max_width(fc_hlineptr[fc_hline].ptr, &fc_target_width,
								 fc_encoding);
				fprintf(fc_fout, "%-s", fc_hlineptr[fc_hline].ptr);

				/*
				 * 填充符
				 */
				fc_swidth -= fc_target_width;
				if (fc_swidth > 0)
					fprintf(fc_fout, "%*s", fc_swidth, " ");

				/*
				 * 换行指示符或分隔符空间
				 */
				if (fc_hlineptr[fc_hline + 1].ptr)
				{
					/* 由于换行，这一行之后还有更多行 */
					if ((fc_opt_border > 0) ||
						(fc_hmultiline && (fc_format != &pg_asciiformat_old)))
						fputs(fc_format->header_nl_right, fc_fout);
					fc_hline++;
				}
				else
				{
					/* 这是头部的最后一行 */
					if ((fc_opt_border > 0) ||
						(fc_hmultiline && (fc_format != &pg_asciiformat_old)))
						fputs(" ", fc_fout);
					fc_hcomplete = 1;
				}
			}
			else
			{
				unsigned int fc_swidth = fc_hwidth + fc_opt_border;

				if ((fc_opt_border < 2) &&
					(fc_hmultiline) &&
					(fc_format == &pg_asciiformat_old))
					fc_swidth++;

				if ((fc_opt_border == 0) &&
					(fc_format != &pg_asciiformat_old) &&
					(fc_hmultiline))
					fc_swidth++;

				fprintf(fc_fout, "%*s", fc_swidth, " ");
			}

			/* 分隔符 */
			if (fc_opt_border > 0)
			{
				if (fc_offset)
					fputs(fc_format->midvrule_wrap, fc_fout);
				else if (fc_dline == 0)
					fputs(fc_dformat->midvrule, fc_fout);
				else
					fputs(fc_format->midvrule_nl, fc_fout);
			}

			/* 数据 */
			if (!fc_dcomplete)
			{
				int			fc_target_width = fc_dwidth,
							fc_bytes_to_output,
							fc_swidth = fc_dwidth;

				/*
				 * 左侧填充或换行指示符
				 */
				fputs(fc_offset == 0 ? " " : fc_format->wrap_left, fc_fout);

				/*
				 * 数据文本
				 */
				fc_bytes_to_output = fc_strlen_max_width(fc_dlineptr[fc_dline].ptr + fc_offset,
												   &fc_target_width, fc_encoding);
				fwrite((char *) (fc_dlineptr[fc_dline].ptr + fc_offset),
					   1, fc_bytes_to_output, fc_fout);

				fc_chars_to_output -= fc_target_width;
				fc_offset += fc_bytes_to_output;

				/* 填充符 */
				fc_swidth -= fc_target_width;

				if (fc_chars_to_output)
				{
					/* 继续换行列 */
					if ((fc_opt_border > 1) ||
						(fc_dmultiline && (fc_format != &pg_asciiformat_old)))
					{
						if (fc_swidth > 0)
							fprintf(fc_fout, "%*s", fc_swidth, " ");
						fputs(fc_format->wrap_right, fc_fout);
					}
				}
				else if (fc_dlineptr[fc_dline + 1].ptr)
				{
					/* 在列中达到了换行 */
					if ((fc_opt_border > 1) ||
						(fc_dmultiline && (fc_format != &pg_asciiformat_old)))
					{
						if (fc_swidth > 0)
							fprintf(fc_fout, "%*s", fc_swidth, " ");
						fputs(fc_format->nl_right, fc_fout);
					}
					fc_dline++;
					fc_offset = 0;
					fc_chars_to_output = fc_dlineptr[fc_dline].width;
				}
				else
				{
					/* 达到单元格的末尾 */
					if (fc_opt_border > 1)
					{
						if (fc_swidth > 0)
							fprintf(fc_fout, "%*s", fc_swidth, " ");
						fputs(" ", fc_fout);
					}
					fc_dcomplete = 1;
				}

				/* 右边界 */
				if (fc_opt_border == 2)
					fputs(fc_dformat->rightvrule, fc_fout);

				fputs("\n", fc_fout);
			}
			else
			{
				/*
				 * 数据耗尽（如果头部由于头部的换行而比
				 * 数据长，则可能发生这种情况）
				 */
				if (fc_opt_border < 2)
					fputs("\n", fc_fout);
				else
					fprintf(fc_fout, "%*s  %s\n", fc_dwidth, "", fc_dformat->rightvrule);
			}
		}
	}

	if (fc_cont->opt->stop_table)
	{
		if (fc_opt_border == 2 && !cancel_pressed)
			fc_print_aligned_vertical_line(fc_format, fc_opt_border, 0, fc_hwidth, fc_dwidth,
										PRINT_RULE_BOTTOM, fc_fout);

		/* 打印页脚 */
		if (!fc_opt_tuples_only && fc_cont->footers != NULL && !cancel_pressed)
		{
			printTableFooter *fc_f;

			if (fc_opt_border < 2)
				fputc('\n', fc_fout);
			for (fc_f = fc_cont->footers; fc_f; fc_f = fc_f->next)
				fprintf(fc_fout, "%s\n", fc_f->data);
		}

		fputc('\n', fc_fout);
	}

	free(fc_hlineptr->ptr);
	free(fc_dlineptr->ptr);
	free(fc_hlineptr);
	free(fc_dlineptr);

	if (fc_is_local_pager)
		ClosePager(fc_fout);
}


/**********************/
/* CSV格式          */
/**********************/


static void fc_csv_escaped_print(const char *fc_str, FILE *fc_fout)
{
	const char *fc_p;

	fputc('"', fc_fout);
	for (fc_p = fc_str; *fc_p; fc_p++)
	{
		if (*fc_p == '"')
			fputc('"', fc_fout);	/* 双引号翻倍 */
		fputc(*fc_p, fc_fout);
	}
	fputc('"', fc_fout);
}

static void fc_csv_print_field(const char *fc_str, FILE *fc_fout, char fc_sep)
{
	/*----------------
	 * 当满足以下条件之一时，封装并转义字段内容：
	 * - 在内容中找到字段分隔符。
	 * - 字段包含CR或LF。
	 * - 字段包含双引号。
	 * - 字段正好是“\.”。
	 * - 字段分隔符为“\”或“.”。
	 * 最后两种情况防止生成服务器的COPY
	 * 命令会将其解释为数据结束标记。我们只需确保完整行不
	 * 精确为“\.”，但为了简单起见，我们在这里应用了更强的限制。
	 *----------------
	 */
	if (strchr(fc_str, fc_sep) != NULL ||
		strcspn(fc_str, "\r\n\"") != strlen(fc_str) ||
		strcmp(fc_str, "\\.") == 0 ||
		fc_sep == '\\' || fc_sep == '.')
		fc_csv_escaped_print(fc_str, fc_fout);
	else
		fputs(fc_str, fc_fout);
}

static void fc_print_csv_text(const printTableContent *fc_cont, FILE *fc_fout)
{
	const char *const *fc_ptr;
	int			fc_i;

	if (cancel_pressed)
		return;

	/*
	 * 标题和页脚在CSV格式中从不打印。如果opt_tuples_only为false，
	 * 则打印头部。
	 *
	 * 尽管RFC 4180说行结束是CRLF，但使用“\n”终止行，
	 * 这在文本模式下打印出来作为与系统相关的EOL字符串
	 * （通常在Unix上是LF，在Windows上是CRLF）。
	 */
	if (fc_cont->opt->start_table && !fc_cont->opt->tuples_only)
	{
		/* 打印标题行 */
		for (fc_ptr = fc_cont->headers; *fc_ptr; fc_ptr++)
		{
			if (fc_ptr != fc_cont->headers)
				fputc(fc_cont->opt->csvFieldSep[0], fc_fout);
			fc_csv_print_field(*fc_ptr, fc_fout, fc_cont->opt->csvFieldSep[0]);
		}
		fputc('\n', fc_fout);
	}

	/* 打印单元格 */
	for (fc_i = 0, fc_ptr = fc_cont->cells; *fc_ptr; fc_i++, fc_ptr++)
	{
		fc_csv_print_field(*fc_ptr, fc_fout, fc_cont->opt->csvFieldSep[0]);
		if ((fc_i + 1) % fc_cont->ncolumns)
			fputc(fc_cont->opt->csvFieldSep[0], fc_fout);
		else
			fputc('\n', fc_fout);
	}
}

static void fc_print_csv_vertical(const printTableContent *fc_cont, FILE *fc_fout)
{
	const char *const *fc_ptr;
	int			fc_i;

	/* 打印记录 */
	for (fc_i = 0, fc_ptr = fc_cont->cells; *fc_ptr; fc_i++, fc_ptr++)
	{
		if (cancel_pressed)
			return;

		/* 打印列名称 */
		fc_csv_print_field(fc_cont->headers[fc_i % fc_cont->ncolumns], fc_fout,
						fc_cont->opt->csvFieldSep[0]);

		/* 打印字段分隔符 */
		fputc(fc_cont->opt->csvFieldSep[0], fc_fout);

		/* 打印字段值 */
		fc_csv_print_field(*fc_ptr, fc_fout, fc_cont->opt->csvFieldSep[0]);

		fputc('\n', fc_fout);
	}
}


/**********************/
/* HTML                */
/**********************/


void html_escaped_print(const char *fc_in, FILE *fc_fout)
{
	const char *fc_p;
	bool		fc_leading_space = true;

	for (fc_p = fc_in; *fc_p; fc_p++)
	{
		switch (*fc_p)
		{
			case '&':
				fputs("&amp;", fc_fout);
				break;
			case '<':
				fputs("&lt;", fc_fout);
				break;
			case '>':
				fputs("&gt;", fc_fout);
				break;
			case '\n':
				fputs("<br />\n", fc_fout);
				break;
			case '"':
				fputs("&quot;", fc_fout);
				break;
			case ' ':
				/* 保护前导空格，用于EXPLAIN输出 */
				if (fc_leading_space)
					fputs("&nbsp;", fc_fout);
				else
					fputs(" ", fc_fout);
				break;
			default:
				fputc(*fc_p, fc_fout);
		}
		if (*fc_p != ' ')
			fc_leading_space = false;
	}
}


static void fc_print_html_text(const printTableContent *fc_cont, FILE *fc_fout)
{
	bool		fc_opt_tuples_only = fc_cont->opt->tuples_only;
	unsigned short fc_opt_border = fc_cont->opt->border;
	const char *fc_opt_table_attr = fc_cont->opt->tableAttr;
	unsigned int fc_i;
	const char *const *fc_ptr;

	if (cancel_pressed)
		return;

	if (fc_cont->opt->start_table)
	{
		fprintf(fc_fout, "<table border=\"%d\"", fc_opt_border);
		if (fc_opt_table_attr)
			fprintf(fc_fout, " %s", fc_opt_table_attr);
		fputs(">\n", fc_fout);

		/* 打印标题 */
		if (!fc_opt_tuples_only && fc_cont->title)
		{
			fputs("  <caption>", fc_fout);
			html_escaped_print(fc_cont->title, fc_fout);
			fputs("</caption>\n", fc_fout);
		}

		/* 打印标题行 */
		if (!fc_opt_tuples_only)
		{
			fputs("  <tr>\n", fc_fout);
			for (fc_ptr = fc_cont->headers; *fc_ptr; fc_ptr++)
			{
				fputs("    <th align=\"center\">", fc_fout);
				html_escaped_print(*fc_ptr, fc_fout);
				fputs("</th>\n", fc_fout);
			}
			fputs("  </tr>\n", fc_fout);
		}
	}

	/* 打印单元格 */
	for (fc_i = 0, fc_ptr = fc_cont->cells; *fc_ptr; fc_i++, fc_ptr++)
	{
		if (fc_i % fc_cont->ncolumns == 0)
		{
			if (cancel_pressed)
				break;
			fputs("  <tr valign=\"top\">\n", fc_fout);
		}

		fprintf(fc_fout, "    <td align=\"%s\">", fc_cont->aligns[(fc_i) % fc_cont->ncolumns] == 'r' ? "right" : "left");
		/* 字符串仅为空格吗？ */
		if ((*fc_ptr)[strspn(*fc_ptr, " \t")] == '\0')
			fputs("&nbsp; ", fc_fout);
		else
			html_escaped_print(*fc_ptr, fc_fout);

		fputs("</td>\n", fc_fout);

		if ((fc_i + 1) % fc_cont->ncolumns == 0)
			fputs("  </tr>\n", fc_fout);
	}

	if (fc_cont->opt->stop_table)
	{
		printTableFooter *fc_footers = fc_footers_with_default(fc_cont);

		fputs("</table>\n", fc_fout);

		/* 打印页脚 */
		if (!fc_opt_tuples_only && fc_footers != NULL && !cancel_pressed)
		{
			printTableFooter *fc_f;

			fputs("<p>", fc_fout);
			for (fc_f = fc_footers; fc_f; fc_f = fc_f->next)
			{
				html_escaped_print(fc_f->data, fc_fout);
				fputs("<br />\n", fc_fout);
			}
			fputs("</p>", fc_fout);
		}

		fputc('\n', fc_fout);
	}
}


static void fc_print_html_vertical(const printTableContent *fc_cont, FILE *fc_fout)
{
	bool		fc_opt_tuples_only = fc_cont->opt->tuples_only;
	unsigned short fc_opt_border = fc_cont->opt->border;
	const char *fc_opt_table_attr = fc_cont->opt->tableAttr;
	unsigned long fc_record = fc_cont->opt->prior_records + 1;
	unsigned int fc_i;
	const char *const *fc_ptr;

	if (cancel_pressed)
		return;

	if (fc_cont->opt->start_table)
	{
		fprintf(fc_fout, "<table border=\"%d\"", fc_opt_border);
		if (fc_opt_table_attr)
			fprintf(fc_fout, " %s", fc_opt_table_attr);
		fputs(">\n", fc_fout);

		/* 打印标题 */
		if (!fc_opt_tuples_only && fc_cont->title)
		{
			fputs("  <caption>", fc_fout);
			html_escaped_print(fc_cont->title, fc_fout);
			fputs("</caption>\n", fc_fout);
		}
	}

	/* 打印记录 */
	for (fc_i = 0, fc_ptr = fc_cont->cells; *fc_ptr; fc_i++, fc_ptr++)
	{
		if (fc_i % fc_cont->ncolumns == 0)
		{
			if (cancel_pressed)
				break;
			if (!fc_opt_tuples_only)
				fprintf(fc_fout,
						"\n  <tr><td colspan=\"2\" align=\"center\">Record %lu</td></tr>\n",
						fc_record++);
			else
				fputs("\n  <tr><td colspan=\"2\">&nbsp;</td></tr>\n", fc_fout);
		}
		fputs("  <tr valign=\"top\">\n"
			  "    <th>", fc_fout);
		html_escaped_print(fc_cont->headers[fc_i % fc_cont->ncolumns], fc_fout);
		fputs("</th>\n", fc_fout);

		fprintf(fc_fout, "    <td align=\"%s\">", fc_cont->aligns[fc_i % fc_cont->ncolumns] == 'r' ? "right" : "left");
		/* 字符串仅为空格吗？ */
		if ((*fc_ptr)[strspn(*fc_ptr, " \t")] == '\0')
			fputs("&nbsp; ", fc_fout);
		else
			html_escaped_print(*fc_ptr, fc_fout);

		fputs("</td>\n  </tr>\n", fc_fout);
	}

	if (fc_cont->opt->stop_table)
	{
		fputs("</table>\n", fc_fout);

		/* 打印页脚 */
		if (!fc_opt_tuples_only && fc_cont->footers != NULL && !cancel_pressed)
		{
			printTableFooter *fc_f;

			fputs("<p>", fc_fout);
			for (fc_f = fc_cont->footers; fc_f; fc_f = fc_f->next)
			{
				html_escaped_print(fc_f->data, fc_fout);
				fputs("<br />\n", fc_fout);
			}
			fputs("</p>", fc_fout);
		}

		fputc('\n', fc_fout);
	}
}


/*************************/
/* ASCIIDOC				 */
/*************************/


static void fc_asciidoc_escaped_print(const char *fc_in, FILE *fc_fout)
{
	const char *fc_p;

	for (fc_p = fc_in; *fc_p; fc_p++)
	{
		switch (*fc_p)
		{
			case '|':
				fputs("\\|", fc_fout);
				break;
			default:
				fputc(*fc_p, fc_fout);
		}
	}
}

static void fc_print_asciidoc_text(const printTableContent *fc_cont, FILE *fc_fout)
{
	bool		fc_opt_tuples_only = fc_cont->opt->tuples_only;
	unsigned short fc_opt_border = fc_cont->opt->border;
	unsigned int fc_i;
	const char *const *fc_ptr;

	if (cancel_pressed)
		return;

	if (fc_cont->opt->start_table)
	{
		/* 如果 popen 失败，默默继续而不使用 pager */
		fputs("\n", fc_fout);

		/* 打印标题 */
		if (!fc_opt_tuples_only && fc_cont->title)
		{
			fputs(".", fc_fout);
			fputs(fc_cont->title, fc_fout);
			fputs("\n", fc_fout);
		}

		/*
 * 释放分配给此结构的所有内存。
 *
 * 一旦调用此函数，该结构将无法使用，除非你再次将其传递给
 * printTableInit()。
 */
		fprintf(fc_fout, "[%scols=\"", !fc_opt_tuples_only ? "options=\"header\"," : "");
		for (fc_i = 0; fc_i < fc_cont->ncolumns; fc_i++)
		{
			if (fc_i != 0)
				fputs(",", fc_fout);
			fprintf(fc_fout, "%s", fc_cont->aligns[(fc_i) % fc_cont->ncolumns] == 'r' ? ">l" : "<l");
		}
		fputs("\"", fc_fout);
		switch (fc_opt_border)
		{
			case 0:
				fputs(",frame=\"none\",grid=\"none\"", fc_fout);
				break;
			case 1:
				fputs(",frame=\"none\"", fc_fout);
				break;
			case 2:
				fputs(",frame=\"all\",grid=\"all\"", fc_fout);
				break;
		}
		fputs("]\n", fc_fout);
		fputs("|====\n", fc_fout);

		/* 打印标题行 */
		if (!fc_opt_tuples_only)
		{
			for (fc_ptr = fc_cont->headers; *fc_ptr; fc_ptr++)
			{
				if (fc_ptr != fc_cont->headers)
					fputs(" ", fc_fout);
				fputs("^l|", fc_fout);
				fc_asciidoc_escaped_print(*fc_ptr, fc_fout);
			}
			fputs("\n", fc_fout);
		}
	}

	/* 打印单元格 */
	for (fc_i = 0, fc_ptr = fc_cont->cells; *fc_ptr; fc_i++, fc_ptr++)
	{
		if (fc_i % fc_cont->ncolumns == 0)
		{
			if (cancel_pressed)
				break;
		}

		if (fc_i % fc_cont->ncolumns != 0)
			fputs(" ", fc_fout);
		fputs("|", fc_fout);

		/*************************/
/* 打印标题 */
/* 开始环境并设置对齐和边框 */
/* 打印表头 */
/* 打印单元格 */
/* 打印页脚 */
/* 0=无, 1=标题, 2=正文 */
/* 打印标题 */
/* 开始环境并设置对齐和边框 */
/* 基本格式 */
/* 假设元组已打印 */
/* 打印记录 */
/* 新记录 */
/* 打印页脚 */
/********************************/
		if ((*fc_ptr)[strspn(*fc_ptr, " \t")] == '\0')
		{
			if ((fc_i + 1) % fc_cont->ncolumns != 0)
				fputs(" ", fc_fout);
		}
		else
			fc_asciidoc_escaped_print(*fc_ptr, fc_fout);

		if ((fc_i + 1) % fc_cont->ncolumns == 0)
			fputs("\n", fc_fout);
	}

	fputs("|====\n", fc_fout);

	if (fc_cont->opt->stop_table)
	{
		printTableFooter *fc_footers = fc_footers_with_default(fc_cont);

		/* 打印页脚 */
		if (!fc_opt_tuples_only && fc_footers != NULL && !cancel_pressed)
		{
			printTableFooter *fc_f;

			fputs("\n....\n", fc_fout);
			for (fc_f = fc_footers; fc_f; fc_f = fc_f->next)
			{
				fputs(fc_f->data, fc_fout);
				fputs("\n", fc_fout);
			}
			fputs("....\n", fc_fout);
		}
	}
}

static void fc_print_asciidoc_vertical(const printTableContent *fc_cont, FILE *fc_fout)
{
	bool		fc_opt_tuples_only = fc_cont->opt->tuples_only;
	unsigned short fc_opt_border = fc_cont->opt->border;
	unsigned long fc_record = fc_cont->opt->prior_records + 1;
	unsigned int fc_i;
	const char *const *fc_ptr;

	if (cancel_pressed)
		return;

	if (fc_cont->opt->start_table)
	{
		/* 如果 popen 失败，默默继续而不使用 pager */
		fputs("\n", fc_fout);

		/* 打印标题 */
		if (!fc_opt_tuples_only && fc_cont->title)
		{
			fputs(".", fc_fout);
			fputs(fc_cont->title, fc_fout);
			fputs("\n", fc_fout);
		}

		/*
 * 释放分配给此结构的所有内存。
 *
 * 一旦调用此函数，该结构将无法使用，除非你再次将其传递给
 * printTableInit()。
 */
		fputs("[cols=\"h,l\"", fc_fout);
		switch (fc_opt_border)
		{
			case 0:
				fputs(",frame=\"none\",grid=\"none\"", fc_fout);
				break;
			case 1:
				fputs(",frame=\"none\"", fc_fout);
				break;
			case 2:
				fputs(",frame=\"all\",grid=\"all\"", fc_fout);
				break;
		}
		fputs("]\n", fc_fout);
		fputs("|====\n", fc_fout);
	}

	/* 打印记录 */
	for (fc_i = 0, fc_ptr = fc_cont->cells; *fc_ptr; fc_i++, fc_ptr++)
	{
		if (fc_i % fc_cont->ncolumns == 0)
		{
			if (cancel_pressed)
				break;
			if (!fc_opt_tuples_only)
				fprintf(fc_fout,
						"2+^|Record %lu\n",
						fc_record++);
			else
				fputs("2+|\n", fc_fout);
		}

		fputs("<l|", fc_fout);
		fc_asciidoc_escaped_print(fc_cont->headers[fc_i % fc_cont->ncolumns], fc_fout);

		fprintf(fc_fout, " %s|", fc_cont->aligns[fc_i % fc_cont->ncolumns] == 'r' ? ">l" : "<l");
		/* 字符串仅为空格吗？ */
		if ((*fc_ptr)[strspn(*fc_ptr, " \t")] == '\0')
			fputs(" ", fc_fout);
		else
			fc_asciidoc_escaped_print(*fc_ptr, fc_fout);
		fputs("\n", fc_fout);
	}

	fputs("|====\n", fc_fout);

	if (fc_cont->opt->stop_table)
	{
		/* 打印页脚 */
		if (!fc_opt_tuples_only && fc_cont->footers != NULL && !cancel_pressed)
		{
			printTableFooter *fc_f;

			fputs("\n....\n", fc_fout);
			for (fc_f = fc_cont->footers; fc_f; fc_f = fc_f->next)
			{
				fputs(fc_f->data, fc_fout);
				fputs("\n", fc_fout);
			}
			fputs("....\n", fc_fout);
		}
	}
}


/*************************/
/* 如果 popen 失败，默默继续而不使用 pager */
/*************************/


static void fc_latex_escaped_print(const char *fc_in, FILE *fc_fout)
{
	const char *fc_p;

	for (fc_p = fc_in; *fc_p; fc_p++)
		switch (*fc_p)
		{
				/*
		 * 如果在处理中途取消了打印，则发出警告。
		 *
		 * 一些 pager，如 less，将 Ctrl-C 作为其命令集的一部分使用。即便如此，我们会中止处理并警告用户我们所做的。如果 pager 因 SIGINT 而退出，则此消息将不会发送到任何地方...
		 */
			case '#':
				fputs("\\#", fc_fout);
				break;
			case '$':
				fputs("\\$", fc_fout);
				break;
			case '%':
				fputs("\\%", fc_fout);
				break;
			case '&':
				fputs("\\&", fc_fout);
				break;
			case '<':
				fputs("\\textless{}", fc_fout);
				break;
			case '>':
				fputs("\\textgreater{}", fc_fout);
				break;
			case '\\':
				fputs("\\textbackslash{}", fc_fout);
				break;
			case '^':
				fputs("\\^{}", fc_fout);
				break;
			case '_':
				fputs("\\_", fc_fout);
				break;
			case '{':
				fputs("\\{", fc_fout);
				break;
			case '|':
				fputs("\\textbar{}", fc_fout);
				break;
			case '}':
				fputs("\\}", fc_fout);
				break;
			case '~':
				fputs("\\~{}", fc_fout);
				break;
			case '\n':
				/*
 * 初始化一个表内容结构。
 *   必须在使用任何其他 printTable 方法之前调用。
 *
 * 标题不会被重复；调用者必须确保缓冲区在 printTableContent 结构的生命周期内可用。
 *
 * 如果调用此函数，则在完成表格后必须调用 printTableCleanup。
 */
				fputs("\\\\", fc_fout);
				break;
			default:
				fputc(*fc_p, fc_fout);
		}
}


static void fc_print_latex_text(const printTableContent *fc_cont, FILE *fc_fout)
{
	bool		fc_opt_tuples_only = fc_cont->opt->tuples_only;
	unsigned short fc_opt_border = fc_cont->opt->border;
	unsigned int fc_i;
	const char *const *fc_ptr;

	if (cancel_pressed)
		return;

	if (fc_opt_border > 3)
		fc_opt_border = 3;

	if (fc_cont->opt->start_table)
	{
		/* 打印标题 */
		if (!fc_opt_tuples_only && fc_cont->title)
		{
			fputs("\\begin{center}\n", fc_fout);
			fc_latex_escaped_print(fc_cont->title, fc_fout);
			fputs("\n\\end{center}\n\n", fc_fout);
		}

		/* 未使用的参数 */
		fputs("\\begin{tabular}{", fc_fout);

		if (fc_opt_border >= 2)
			fputs("| ", fc_fout);
		for (fc_i = 0; fc_i < fc_cont->ncolumns; fc_i++)
		{
			fputc(*(fc_cont->aligns + fc_i), fc_fout);
			if (fc_opt_border != 0 && fc_i < fc_cont->ncolumns - 1)
				fputs(" | ", fc_fout);
		}
		if (fc_opt_border >= 2)
			fputs(" |", fc_fout);

		fputs("}\n", fc_fout);

		if (!fc_opt_tuples_only && fc_opt_border >= 2)
			fputs("\\hline\n", fc_fout);

		/* 打印标题行 */
		if (!fc_opt_tuples_only)
		{
			for (fc_i = 0, fc_ptr = fc_cont->headers; fc_i < fc_cont->ncolumns; fc_i++, fc_ptr++)
			{
				if (fc_i != 0)
					fputs(" & ", fc_fout);
				fputs("\\textit{", fc_fout);
				fc_latex_escaped_print(*fc_ptr, fc_fout);
				fputc('}', fc_fout);
			}
			fputs(" \\\\\n", fc_fout);
			fputs("\\hline\n", fc_fout);
		}
	}

	/* 打印单元格 */
	for (fc_i = 0, fc_ptr = fc_cont->cells; *fc_ptr; fc_i++, fc_ptr++)
	{
		fc_latex_escaped_print(*fc_ptr, fc_fout);

		if ((fc_i + 1) % fc_cont->ncolumns == 0)
		{
			fputs(" \\\\\n", fc_fout);
			if (fc_opt_border == 3)
				fputs("\\hline\n", fc_fout);
			if (cancel_pressed)
				break;
		}
		else
			fputs(" & ", fc_fout);
	}

	if (fc_cont->opt->stop_table)
	{
		printTableFooter *fc_footers = fc_footers_with_default(fc_cont);

		if (fc_opt_border == 2)
			fputs("\\hline\n", fc_fout);

		fputs("\\end{tabular}\n\n\\noindent ", fc_fout);

		/* 打印页脚 */
		if (fc_footers && !fc_opt_tuples_only && !cancel_pressed)
		{
			printTableFooter *fc_f;

			for (fc_f = fc_footers; fc_f; fc_f = fc_f->next)
			{
				fc_latex_escaped_print(fc_f->data, fc_fout);
				fputs(" \\\\\n", fc_fout);
			}
		}

		fputc('\n', fc_fout);
	}
}


/*************************/
/*
 * 释放分配给此结构的所有内存。
 *
 * 一旦调用此函数，该结构将无法使用，除非你再次将其传递给
 * printTableInit()。
 */
/*************************/


static void fc_print_latex_longtable_text(const printTableContent *fc_cont, FILE *fc_fout)
{
	bool		fc_opt_tuples_only = fc_cont->opt->tuples_only;
	unsigned short fc_opt_border = fc_cont->opt->border;
	unsigned int fc_i;
	const char *fc_opt_table_attr = fc_cont->opt->tableAttr;
	const char *fc_next_opt_table_attr_char = fc_opt_table_attr;
	const char *fc_last_opt_table_attr_char = NULL;
	const char *const *fc_ptr;

	if (cancel_pressed)
		return;

	if (fc_opt_border > 3)
		fc_opt_border = 3;

	if (fc_cont->opt->start_table)
	{
		/* 未使用的参数 */
		fputs("\\begin{longtable}{", fc_fout);

		if (fc_opt_border >= 2)
			fputs("| ", fc_fout);

		for (fc_i = 0; fc_i < fc_cont->ncolumns; fc_i++)
		{
			/*
 * 使用此功能以支持的格式打印任何表格。
 *
 * cont: 表格数据和格式选项
 * fout: 打印位置
 * is_pager: 如果调用者已将 fout 重定向为分页管道，则为 true
 * flog: 如果不为 null，也将在那里打印表格（用于 --log-file 选项）
 */
			/* print_aligned_*() 自行处理分页器 */
			if (*(fc_cont->aligns + fc_i) == 'l' && fc_opt_table_attr)
			{
#define LONGTABLE_WHITESPACE	" \t\n"

				/* 清除输出流上的任何现有错误指示 */
				fc_next_opt_table_attr_char += strspn(fc_next_opt_table_attr_char,
												   LONGTABLE_WHITESPACE);
				/* 打印数据 */
				if (fc_next_opt_table_attr_char[0] != '\0')
				{
					fputs("p{", fc_fout);
					fwrite(fc_next_opt_table_attr_char, strcspn(fc_next_opt_table_attr_char,
															 LONGTABLE_WHITESPACE), 1, fc_fout);
					fc_last_opt_table_attr_char = fc_next_opt_table_attr_char;
					fc_next_opt_table_attr_char += strcspn(fc_next_opt_table_attr_char,
														LONGTABLE_WHITESPACE);
					fputs("\\textwidth}", fc_fout);
				}
				/*
			 * 在扩展自动模式下，如果传入了分页器则强制垂直；
			 * 否则我们可能会对查询结果的不同块做出不同决定。
			 */
				else if (fc_last_opt_table_attr_char != NULL)
				{
					fputs("p{", fc_fout);
					fwrite(fc_last_opt_table_attr_char, strcspn(fc_last_opt_table_attr_char,
															 LONGTABLE_WHITESPACE), 1, fc_fout);
					fputs("\\textwidth}", fc_fout);
				}
				else
					fputc('l', fc_fout);
			}
			else
				fputc(*(fc_cont->aligns + fc_i), fc_fout);

			if (fc_opt_border != 0 && fc_i < fc_cont->ncolumns - 1)
				fputs(" | ", fc_fout);
		}

		if (fc_opt_border >= 2)
			fputs(" |", fc_fout);

		fputs("}\n", fc_fout);

		/* 打印标题行 */
		if (!fc_opt_tuples_only)
		{
			/* 断言调用者提供了足够的 translate_columns[] 条目 */
			if (fc_opt_border >= 2)
				fputs("\\toprule\n", fc_fout);
			for (fc_i = 0, fc_ptr = fc_cont->headers; fc_i < fc_cont->ncolumns; fc_i++, fc_ptr++)
			{
				if (fc_i != 0)
					fputs(" & ", fc_fout);
				fputs("\\small\\textbf{\\textit{", fc_fout);
				fc_latex_escaped_print(*fc_ptr, fc_fout);
				fputs("}}", fc_fout);
			}
			fputs(" \\\\\n", fc_fout);
			fputs("\\midrule\n\\endfirsthead\n", fc_fout);

			/* 设置单元格 */
			if (fc_opt_border >= 2)
				fputs("\\toprule\n", fc_fout);
			for (fc_i = 0, fc_ptr = fc_cont->headers; fc_i < fc_cont->ncolumns; fc_i++, fc_ptr++)
			{
				if (fc_i != 0)
					fputs(" & ", fc_fout);
				fputs("\\small\\textbf{\\textit{", fc_fout);
				fc_latex_escaped_print(*fc_ptr, fc_fout);
				fputs("}}", fc_fout);
			}
			fputs(" \\\\\n", fc_fout);
			/* 设置页脚 */
			if (fc_opt_border != 3)
				fputs("\\midrule\n", fc_fout);
			fputs("\\endhead\n", fc_fout);

			/* 不接受空的 decimal_point 字符串 */
			if (!fc_opt_tuples_only && fc_cont->title)
			{
				/* SQL 输出标准 */
				if (fc_opt_border == 2)
					fputs("\\bottomrule\n", fc_fout);
				fputs("\\caption[", fc_fout);
				fc_latex_escaped_print(fc_cont->title, fc_fout);
				fputs(" (Continued)]{", fc_fout);
				fc_latex_escaped_print(fc_cont->title, fc_fout);
				fputs("}\n\\endfoot\n", fc_fout);
				if (fc_opt_border == 2)
					fputs("\\bottomrule\n", fc_fout);
				fputs("\\caption[", fc_fout);
				fc_latex_escaped_print(fc_cont->title, fc_fout);
				fputs("]{", fc_fout);
				fc_latex_escaped_print(fc_cont->title, fc_fout);
				fputs("}\n\\endlastfoot\n", fc_fout);
			}
			/*
	 * 尽管开放组标准允许区域设置提供多个
	 * 组宽度，但我们只考虑第一个，并忽略任何通过指定 CHAR_MAX
	 * 来抑制分组的尝试。与后端的
	 * cash.c 一样，我们必须应用范围检查以避免被变体
	 * CHAR_MAX 值欺骗。
	 */
			else if (fc_opt_border >= 2)
			{
				fputs("\\bottomrule\n\\endfoot\n", fc_fout);
				fputs("\\bottomrule\n\\endlastfoot\n", fc_fout);
			}
		}
	}

	/* 打印单元格 */
	for (fc_i = 0, fc_ptr = fc_cont->cells; *fc_ptr; fc_i++, fc_ptr++)
	{
		/* 也不接受空的 thousands_sep 字符串 */
		if (fc_i != 0 && fc_i % fc_cont->ncolumns != 0)
			fputs("\n&\n", fc_fout);
		fputs("\\raggedright{", fc_fout);
		fc_latex_escaped_print(*fc_ptr, fc_fout);
		fputc('}', fc_fout);
		if ((fc_i + 1) % fc_cont->ncolumns == 0)
		{
			fputs(" \\tabularnewline\n", fc_fout);
			if (fc_opt_border == 3)
				fputs(" \\hline\n", fc_fout);
		}
		if (cancel_pressed)
			break;
	}

	if (fc_cont->opt->stop_table)
		fputs("\\end{longtable}\n", fc_fout);
}


static void fc_print_latex_vertical(const printTableContent *fc_cont, FILE *fc_fout)
{
	bool		fc_opt_tuples_only = fc_cont->opt->tuples_only;
	unsigned short fc_opt_border = fc_cont->opt->border;
	unsigned long fc_record = fc_cont->opt->prior_records + 1;
	unsigned int fc_i;
	const char *const *fc_ptr;

	if (cancel_pressed)
		return;

	if (fc_opt_border > 2)
		fc_opt_border = 2;

	if (fc_cont->opt->start_table)
	{
		/* 打印标题 */
		if (!fc_opt_tuples_only && fc_cont->title)
		{
			fputs("\\begin{center}\n", fc_fout);
			fc_latex_escaped_print(fc_cont->title, fc_fout);
			fputs("\n\\end{center}\n\n", fc_fout);
		}

		/* 未使用的参数 */
		fputs("\\begin{tabular}{", fc_fout);
		if (fc_opt_border == 0)
			fputs("cl", fc_fout);
		else if (fc_opt_border == 1)
			fputs("c|l", fc_fout);
		else if (fc_opt_border == 2)
			fputs("|c|l|", fc_fout);
		fputs("}\n", fc_fout);
	}

	/* 打印记录 */
	for (fc_i = 0, fc_ptr = fc_cont->cells; *fc_ptr; fc_i++, fc_ptr++)
	{
		/*
	 * 注意：此函数主要存在是为了保持一个
	 * printTableOpt 结构可以被初始化为零以获得默认
	 * 行为。
	 */
		if (fc_i % fc_cont->ncolumns == 0)
		{
			if (cancel_pressed)
				break;
			if (!fc_opt_tuples_only)
			{
				if (fc_opt_border == 2)
				{
					fputs("\\hline\n", fc_fout);
					fprintf(fc_fout, "\\multicolumn{2}{|c|}{\\textit{Record %lu}} \\\\\n", fc_record++);
				}
				else
					fprintf(fc_fout, "\\multicolumn{2}{c}{\\textit{Record %lu}} \\\\\n", fc_record++);
			}
			if (fc_opt_border >= 1)
				fputs("\\hline\n", fc_fout);
		}

		fc_latex_escaped_print(fc_cont->headers[fc_i % fc_cont->ncolumns], fc_fout);
		fputs(" & ", fc_fout);
		fc_latex_escaped_print(*fc_ptr, fc_fout);
		fputs(" \\\\\n", fc_fout);
	}

	if (fc_cont->opt->stop_table)
	{
		if (fc_opt_border == 2)
			fputs("\\hline\n", fc_fout);

		fputs("\\end{tabular}\n\n\\noindent ", fc_fout);

		/* 打印页脚 */
		if (fc_cont->footers && !fc_opt_tuples_only && !cancel_pressed)
		{
			printTableFooter *fc_f;

			for (fc_f = fc_cont->footers; fc_f; fc_f = fc_f->next)
			{
				fc_latex_escaped_print(fc_f->data, fc_fout);
				fputs(" \\\\\n", fc_fout);
			}
		}

		fputc('\n', fc_fout);
	}
}


/*************************/
/*
 * 计算到字符串末尾或 *target_width 
 * 显示字符位置的字节距离，取决于哪一个先到。更新 *target_width 
 * 为实际填充的显示字符位置的数量。
 */
/*************************/


static void fc_troff_ms_escaped_print(const char *fc_in, FILE *fc_fout)
{
	const char *fc_p;

	for (fc_p = fc_in; *fc_p; fc_p++)
		switch (*fc_p)
		{
			case '\\':
				fputs("\\(rs", fc_fout);
				break;
			default:
				fputc(*fc_p, fc_fout);
		}
}


static void fc_print_troff_ms_text(const printTableContent *fc_cont, FILE *fc_fout)
{
	bool		fc_opt_tuples_only = fc_cont->opt->tuples_only;
	unsigned short fc_opt_border = fc_cont->opt->border;
	unsigned int fc_i;
	const char *const *fc_ptr;

	if (cancel_pressed)
		return;

	if (fc_opt_border > 2)
		fc_opt_border = 2;

	if (fc_cont->opt->start_table)
	{
		/* 打印标题 */
		if (!fc_opt_tuples_only && fc_cont->title)
		{
			fputs(".LP\n.DS C\n", fc_fout);
			fc_troff_ms_escaped_print(fc_cont->title, fc_fout);
			fputs("\n.DE\n", fc_fout);
		}

		/* 未使用的参数 */
		fputs(".LP\n.TS\n", fc_fout);
		if (fc_opt_border == 2)
			fputs("center box;\n", fc_fout);
		else
			fputs("center;\n", fc_fout);

		for (fc_i = 0; fc_i < fc_cont->ncolumns; fc_i++)
		{
			fputc(*(fc_cont->aligns + fc_i), fc_fout);
			if (fc_opt_border > 0 && fc_i < fc_cont->ncolumns - 1)
				fputs(" | ", fc_fout);
		}
		fputs(".\n", fc_fout);

		/* 打印标题行 */
		if (!fc_opt_tuples_only)
		{
			for (fc_i = 0, fc_ptr = fc_cont->headers; fc_i < fc_cont->ncolumns; fc_i++, fc_ptr++)
			{
				if (fc_i != 0)
					fputc('\t', fc_fout);
				fputs("\\fI", fc_fout);
				fc_troff_ms_escaped_print(*fc_ptr, fc_fout);
				fputs("\\fP", fc_fout);
			}
			fputs("\n_\n", fc_fout);
		}
	}

	/* 打印单元格 */
	for (fc_i = 0, fc_ptr = fc_cont->cells; *fc_ptr; fc_i++, fc_ptr++)
	{
		fc_troff_ms_escaped_print(*fc_ptr, fc_fout);

		if ((fc_i + 1) % fc_cont->ncolumns == 0)
		{
			fputc('\n', fc_fout);
			if (cancel_pressed)
				break;
		}
		else
			fputc('\t', fc_fout);
	}

	if (fc_cont->opt->stop_table)
	{
		printTableFooter *fc_footers = fc_footers_with_default(fc_cont);

		fputs(".TE\n.DS L\n", fc_fout);

		/* 打印页脚 */
		if (fc_footers && !fc_opt_tuples_only && !cancel_pressed)
		{
			printTableFooter *fc_f;

			for (fc_f = fc_footers; fc_f; fc_f = fc_f->next)
			{
				fc_troff_ms_escaped_print(fc_f->data, fc_fout);
				fputc('\n', fc_fout);
			}
		}

		fputs(".DE\n", fc_fout);
	}
}


static void fc_print_troff_ms_vertical(const printTableContent *fc_cont, FILE *fc_fout)
{
	bool		fc_opt_tuples_only = fc_cont->opt->tuples_only;
	unsigned short fc_opt_border = fc_cont->opt->border;
	unsigned long fc_record = fc_cont->opt->prior_records + 1;
	unsigned int fc_i;
	const char *const *fc_ptr;
	unsigned short fc_current_format = 0;	/* 0=none, 1=header, 2=body */

	if (cancel_pressed)
		return;

	if (fc_opt_border > 2)
		fc_opt_border = 2;

	if (fc_cont->opt->start_table)
	{
		/* 打印标题 */
		if (!fc_opt_tuples_only && fc_cont->title)
		{
			fputs(".LP\n.DS C\n", fc_fout);
			fc_troff_ms_escaped_print(fc_cont->title, fc_fout);
			fputs("\n.DE\n", fc_fout);
		}

		/* 未使用的参数 */
		fputs(".LP\n.TS\n", fc_fout);
		if (fc_opt_border == 2)
			fputs("center box;\n", fc_fout);
		else
			fputs("center;\n", fc_fout);

		/* basic format */
		if (fc_opt_tuples_only)
			fputs("c l;\n", fc_fout);
	}
	else
		fc_current_format = 2;		/* assume tuples printed already */

	/* 打印记录 */
	for (fc_i = 0, fc_ptr = fc_cont->cells; *fc_ptr; fc_i++, fc_ptr++)
	{
		/*
	 * 注意：此函数主要存在是为了保持一个
	 * printTableOpt 结构可以被初始化为零以获得默认
	 * 行为。
	 */
		if (fc_i % fc_cont->ncolumns == 0)
		{
			if (cancel_pressed)
				break;
			if (!fc_opt_tuples_only)
			{
				if (fc_current_format != 1)
				{
					if (fc_opt_border == 2 && fc_record > 1)
						fputs("_\n", fc_fout);
					if (fc_current_format != 0)
						fputs(".T&\n", fc_fout);
					fputs("c s.\n", fc_fout);
					fc_current_format = 1;
				}
				fprintf(fc_fout, "\\fIRecord %lu\\fP\n", fc_record++);
			}
			if (fc_opt_border >= 1)
				fputs("_\n", fc_fout);
		}

		if (!fc_opt_tuples_only)
		{
			if (fc_current_format != 2)
			{
				if (fc_current_format != 0)
					fputs(".T&\n", fc_fout);
				if (fc_opt_border != 1)
					fputs("c l.\n", fc_fout);
				else
					fputs("c | l.\n", fc_fout);
				fc_current_format = 2;
			}
		}

		fc_troff_ms_escaped_print(fc_cont->headers[fc_i % fc_cont->ncolumns], fc_fout);
		fputc('\t', fc_fout);
		fc_troff_ms_escaped_print(*fc_ptr, fc_fout);

		fputc('\n', fc_fout);
	}

	if (fc_cont->opt->stop_table)
	{
		fputs(".TE\n.DS L\n", fc_fout);

		/* 打印页脚 */
		if (fc_cont->footers && !fc_opt_tuples_only && !cancel_pressed)
		{
			printTableFooter *fc_f;

			for (fc_f = fc_cont->footers; fc_f; fc_f = fc_f->next)
			{
				fc_troff_ms_escaped_print(fc_f->data, fc_fout);
				fputc('\n', fc_fout);
			}
		}

		fputs(".DE\n", fc_fout);
	}
}


/********************************/
/* Public functions				*/
/********************************/


/*
 * disable_sigpipe_trap
 *
 * Turn off SIGPIPE interrupt --- call this before writing to a temporary
 * query output file that is a pipe.
 *
 * No-op on Windows, where there's no SIGPIPE interrupts.
 */
void disable_sigpipe_trap(void)
{
#ifndef WIN32
	pqsignal(SIGPIPE, SIG_IGN);
#endif
}

/*
 * restore_sigpipe_trap
 *
 * Restore normal SIGPIPE interrupt --- call this when done writing to a
 * temporary query output file that was (or might have been) a pipe.
 *
 * Note: within psql, we enable SIGPIPE interrupts unless the permanent query
 * output file is a pipe, in which case they should be kept off.  This
 * approach works only because psql is not currently complicated enough to
 * have nested usages of short-lived output files.  Otherwise we'd probably
 * need a genuine save-and-restore-state approach; but for now, that would be
 * useless complication.  In non-psql programs, this always enables SIGPIPE.
 *
 * No-op on Windows, where there's no SIGPIPE interrupts.
 */
void restore_sigpipe_trap(void)
{
#ifndef WIN32
	pqsignal(SIGPIPE, always_ignore_sigpipe ? SIG_IGN : SIG_DFL);
#endif
}

/*
 * set_sigpipe_trap_state
 *
 * Set the trap state that restore_sigpipe_trap should restore to.
 */
void set_sigpipe_trap_state(bool fc_ignore)
{
	always_ignore_sigpipe = fc_ignore;
}


/*
 * PageOutput
 *
 * Tests if pager is needed and returns appropriate FILE pointer.
 *
 * If the topt argument is NULL no pager is used.
 */
FILE * PageOutput(int fc_lines, const printTableOpt *fc_topt)
{
	/* check whether we need / can / are supposed to use pager */
	if (fc_topt && fc_topt->pager && isatty(fileno(stdin)) && isatty(fileno(stdout)))
	{
#ifdef TIOCGWINSZ
		unsigned short int fc_pager = fc_topt->pager;
		int			fc_min_lines = fc_topt->pager_min_lines;
		int			fc_result;
		struct winsize fc_screen_size;

		fc_result = ioctl(fileno(stdout), TIOCGWINSZ, &fc_screen_size);

		/* >= accounts for a one-line prompt */
		if (fc_result == -1
			|| (fc_lines >= fc_screen_size.ws_row && fc_lines >= fc_min_lines)
			|| fc_pager > 1)
#endif
		{
			const char *fc_pagerprog;
			FILE	   *fc_pagerpipe;

			fc_pagerprog = getenv("PSQL_PAGER");
			if (!fc_pagerprog)
				fc_pagerprog = getenv("PAGER");
			if (!fc_pagerprog)
				fc_pagerprog = DEFAULT_PAGER;
			else
			{
				/* if PAGER is empty or all-white-space, don't use pager */
				if (strspn(fc_pagerprog, " \t\r\n") == strlen(fc_pagerprog))
					return stdout;
			}
			disable_sigpipe_trap();
			fc_pagerpipe = popen(fc_pagerprog, "w");
			if (fc_pagerpipe)
				return fc_pagerpipe;
			/* if popen fails, silently proceed without pager */
			restore_sigpipe_trap();
		}
	}

	return stdout;
}

/*
 * ClosePager
 *
 * Close previously opened pager pipe, if any
 */
void ClosePager(FILE *fc_pagerpipe)
{
	if (fc_pagerpipe && fc_pagerpipe != stdout)
	{
		/*
		 * If printing was canceled midstream, warn about it.
		 *
		 * Some pagers like less use Ctrl-C as part of their command set. Even
		 * so, we abort our processing and warn the user what we did.  If the
		 * pager quit as a result of the SIGINT, this message won't go
		 * anywhere ...
		 */
		if (cancel_pressed)
			fprintf(fc_pagerpipe, _("Interrupted\n"));

		pclose(fc_pagerpipe);
		restore_sigpipe_trap();
	}
}

/*
 * Initialise a table contents struct.
 *		Must be called before any other printTable method is used.
 *
 * The title is not duplicated; the caller must ensure that the buffer
 * is available for the lifetime of the printTableContent struct.
 *
 * If you call this, you must call printTableCleanup once you're done with the
 * table.
 */
void printTableInit(printTableContent *const fc_content, const printTableOpt *fc_opt,
			   const char *fc_title, const int fc_ncolumns, const int fc_nrows)
{
	fc_content->opt = fc_opt;
	fc_content->title = fc_title;
	fc_content->ncolumns = fc_ncolumns;
	fc_content->nrows = fc_nrows;

	fc_content->headers = pg_malloc0((fc_ncolumns + 1) * sizeof(*fc_content->headers));

	fc_content->cells = pg_malloc0((fc_ncolumns * fc_nrows + 1) * sizeof(*fc_content->cells));

	fc_content->cellmustfree = NULL;
	fc_content->footers = NULL;

	fc_content->aligns = pg_malloc0((fc_ncolumns + 1) * sizeof(*fc_content->align));

	fc_content->header = fc_content->headers;
	fc_content->cell = fc_content->cells;
	fc_content->footer = fc_content->footers;
	fc_content->align = fc_content->aligns;
	fc_content->cellsadded = 0;
}

/*
 * Add a header to the table.
 *
 * Headers are not duplicated; you must ensure that the header string is
 * available for the lifetime of the printTableContent struct.
 *
 * If translate is true, the function will pass the header through gettext.
 * Otherwise, the header will not be translated.
 *
 * align is either 'l' or 'r', and specifies the alignment for cells in this
 * column.
 */
void printTableAddHeader(printTableContent *const fc_content, char *fc_header,
					const bool fc_translate, const char fc_align)
{
#ifndef ENABLE_NLS
	(void) fc_translate;			/* unused parameter */
#endif

	if (fc_content->header >= fc_content->headers + fc_content->ncolumns)
	{
		fprintf(stderr, _("Cannot add header to table content: "
						  "column count of %d exceeded.\n"),
				fc_content->ncolumns);
		exit(EXIT_FAILURE);
	}

	*fc_content->header = (char *) mbvalidate((unsigned char *) fc_header,
										   fc_content->opt->encoding);
#ifdef ENABLE_NLS
	if (translate)
		*content->header = _(*content->header);
#endif
	fc_content->header++;

	*fc_content->align = fc_align;
	fc_content->align++;
}

/*
 * Add a cell to the table.
 *
 * Cells are not duplicated; you must ensure that the cell string is available
 * for the lifetime of the printTableContent struct.
 *
 * If translate is true, the function will pass the cell through gettext.
 * Otherwise, the cell will not be translated.
 *
 * If mustfree is true, the cell string is freed by printTableCleanup().
 * Note: Automatic freeing of translatable strings is not supported.
 */
void printTableAddCell(printTableContent *const fc_content, char *fc_cell,
				  const bool fc_translate, const bool fc_mustfree)
{
#ifndef ENABLE_NLS
	(void) fc_translate;			/* unused parameter */
#endif

	if (fc_content->cellsadded >= fc_content->ncolumns * fc_content->nrows)
	{
		fprintf(stderr, _("Cannot add cell to table content: "
						  "total cell count of %d exceeded.\n"),
				fc_content->ncolumns * fc_content->nrows);
		exit(EXIT_FAILURE);
	}

	*fc_content->cell = (char *) mbvalidate((unsigned char *) fc_cell,
										 fc_content->opt->encoding);

#ifdef ENABLE_NLS
	if (translate)
		*content->cell = _(*content->cell);
#endif

	if (fc_mustfree)
	{
		if (fc_content->cellmustfree == NULL)
			fc_content->cellmustfree =
				pg_malloc0((fc_content->ncolumns * fc_content->nrows + 1) * sizeof(bool));

		fc_content->cellmustfree[fc_content->cellsadded] = true;
	}
	fc_content->cell++;
	fc_content->cellsadded++;
}

/*
 * Add a footer to the table.
 *
 * Footers are added as elements of a singly-linked list, and the content is
 * strdup'd, so there is no need to keep the original footer string around.
 *
 * Footers are never translated by the function.  If you want the footer
 * translated you must do so yourself, before calling printTableAddFooter.  The
 * reason this works differently to headers and cells is that footers tend to
 * be made of up individually translated components, rather than being
 * translated as a whole.
 */
void printTableAddFooter(printTableContent *const fc_content, const char *fc_footer)
{
	printTableFooter *fc_f;

	fc_f = pg_malloc0(sizeof(*fc_f));
	fc_f->data = pg_strdup(fc_footer);

	if (fc_content->footers == NULL)
		fc_content->footers = fc_f;
	else
		fc_content->footer->next = fc_f;

	fc_content->footer = fc_f;
}

/*
 * Change the content of the last-added footer.
 *
 * The current contents of the last-added footer are freed, and replaced by the
 * content given in *footer.  If there was no previous footer, add a new one.
 *
 * The content is strdup'd, so there is no need to keep the original string
 * around.
 */
void printTableSetFooter(printTableContent *const fc_content, const char *fc_footer)
{
	if (fc_content->footers != NULL)
	{
		free(fc_content->footer->data);
		fc_content->footer->data = pg_strdup(fc_footer);
	}
	else
		printTableAddFooter(fc_content, fc_footer);
}

/*
 * Free all memory allocated to this struct.
 *
 * Once this has been called, the struct is unusable unless you pass it to
 * printTableInit() again.
 */
void printTableCleanup(printTableContent *const fc_content)
{
	if (fc_content->cellmustfree)
	{
		int			fc_i;

		for (fc_i = 0; fc_i < fc_content->nrows * fc_content->ncolumns; fc_i++)
		{
			if (fc_content->cellmustfree[fc_i])
				free(unconstify(char *, fc_content->cells[fc_i]));
		}
		free(fc_content->cellmustfree);
		fc_content->cellmustfree = NULL;
	}
	free(fc_content->headers);
	free(fc_content->cells);
	free(fc_content->aligns);

	fc_content->opt = NULL;
	fc_content->title = NULL;
	fc_content->headers = NULL;
	fc_content->cells = NULL;
	fc_content->aligns = NULL;
	fc_content->header = NULL;
	fc_content->cell = NULL;
	fc_content->align = NULL;

	if (fc_content->footers)
	{
		for (fc_content->footer = fc_content->footers; fc_content->footer;)
		{
			printTableFooter *fc_f;

			fc_f = fc_content->footer;
			fc_content->footer = fc_f->next;
			free(fc_f->data);
			free(fc_f);
		}
	}
	fc_content->footers = NULL;
	fc_content->footer = NULL;
}

/*
 * IsPagerNeeded
 *
 * Setup pager if required
 */
static void fc_IsPagerNeeded(const printTableContent *fc_cont, int fc_extra_lines, bool fc_expanded,
			  FILE **fc_fout, bool *fc_is_pager)
{
	if (*fc_fout == stdout)
	{
		int			fc_lines;

		if (fc_expanded)
			fc_lines = (fc_cont->ncolumns + 1) * fc_cont->nrows;
		else
			fc_lines = fc_cont->nrows + 1;

		if (!fc_cont->opt->tuples_only)
		{
			printTableFooter *fc_f;

			/*
			 * FIXME -- this is slightly bogus: it counts the number of
			 * footers, not the number of lines in them.
			 */
			for (fc_f = fc_cont->footers; fc_f; fc_f = fc_f->next)
				fc_lines++;
		}

		*fc_fout = PageOutput(fc_lines + fc_extra_lines, fc_cont->opt);
		*fc_is_pager = (*fc_fout != stdout);
	}
	else
		*fc_is_pager = false;
}

/*
 * Use this to print any table in the supported formats.
 *
 * cont: table data and formatting options
 * fout: where to print to
 * is_pager: true if caller has already redirected fout to be a pager pipe
 * flog: if not null, also print the table there (for --log-file option)
 */
void printTable(const printTableContent *fc_cont,
		   FILE *fc_fout, bool fc_is_pager, FILE *fc_flog)
{
	bool		fc_is_local_pager = false;

	if (cancel_pressed)
		return;

	if (fc_cont->opt->format == PRINT_NOTHING)
		return;

	/* print_aligned_*() handle the pager themselves */
	if (!fc_is_pager &&
		fc_cont->opt->format != PRINT_ALIGNED &&
		fc_cont->opt->format != PRINT_WRAPPED)
	{
		fc_IsPagerNeeded(fc_cont, 0, (fc_cont->opt->expanded == 1), &fc_fout, &fc_is_pager);
		fc_is_local_pager = fc_is_pager;
	}

	/* 清除输出流上任何预先存在的错误指示 */
	clearerr(fc_fout);

	/* print the stuff */

	if (fc_flog)
		fc_print_aligned_text(fc_cont, fc_flog, false);

	switch (fc_cont->opt->format)
	{
		case PRINT_UNALIGNED:
			if (fc_cont->opt->expanded == 1)
				fc_print_unaligned_vertical(fc_cont, fc_fout);
			else
				fc_print_unaligned_text(fc_cont, fc_fout);
			break;
		case PRINT_ALIGNED:
		case PRINT_WRAPPED:

			/*
			 * In expanded-auto mode, force vertical if a pager is passed in;
			 * else we may make different decisions for different hunks of the
			 * query result.
			 */
			if (fc_cont->opt->expanded == 1 ||
				(fc_cont->opt->expanded == 2 && fc_is_pager))
				fc_print_aligned_vertical(fc_cont, fc_fout, fc_is_pager);
			else
				fc_print_aligned_text(fc_cont, fc_fout, fc_is_pager);
			break;
		case PRINT_CSV:
			if (fc_cont->opt->expanded == 1)
				fc_print_csv_vertical(fc_cont, fc_fout);
			else
				fc_print_csv_text(fc_cont, fc_fout);
			break;
		case PRINT_HTML:
			if (fc_cont->opt->expanded == 1)
				fc_print_html_vertical(fc_cont, fc_fout);
			else
				fc_print_html_text(fc_cont, fc_fout);
			break;
		case PRINT_ASCIIDOC:
			if (fc_cont->opt->expanded == 1)
				fc_print_asciidoc_vertical(fc_cont, fc_fout);
			else
				fc_print_asciidoc_text(fc_cont, fc_fout);
			break;
		case PRINT_LATEX:
			if (fc_cont->opt->expanded == 1)
				fc_print_latex_vertical(fc_cont, fc_fout);
			else
				fc_print_latex_text(fc_cont, fc_fout);
			break;
		case PRINT_LATEX_LONGTABLE:
			if (fc_cont->opt->expanded == 1)
				fc_print_latex_vertical(fc_cont, fc_fout);
			else
				fc_print_latex_longtable_text(fc_cont, fc_fout);
			break;
		case PRINT_TROFF_MS:
			if (fc_cont->opt->expanded == 1)
				fc_print_troff_ms_vertical(fc_cont, fc_fout);
			else
				fc_print_troff_ms_text(fc_cont, fc_fout);
			break;
		default:
			fprintf(stderr, _("invalid output format (internal error): %d"),
					fc_cont->opt->format);
			exit(EXIT_FAILURE);
	}

	if (fc_is_local_pager)
		ClosePager(fc_fout);
}

/*
 * Use this to print query results
 *
 * result: result of a successful query
 * opt: formatting options
 * fout: where to print to
 * is_pager: true if caller has already redirected fout to be a pager pipe
 * flog: if not null, also print the data there (for --log-file option)
 */
void printQuery(const PGresult *fc_result, const printQueryOpt *fc_opt,
		   FILE *fc_fout, bool fc_is_pager, FILE *fc_flog)
{
	printTableContent fc_cont;
	int			fc_i,
				fc_r,
				fc_c;

	if (cancel_pressed)
		return;

	printTableInit(&fc_cont, &fc_opt->topt, fc_opt->title,
				   PQnfields(fc_result), PQntuples(fc_result));

	/* Assert caller supplied enough translate_columns[] entries */
	Assert(fc_opt->translate_columns == NULL ||
		   fc_opt->n_translate_columns >= fc_cont.ncolumns);

	for (fc_i = 0; fc_i < fc_cont.ncolumns; fc_i++)
	{
		printTableAddHeader(&fc_cont, PQfname(fc_result, fc_i),
							fc_opt->translate_header,
							column_type_alignment(PQftype(fc_result, fc_i)));
	}

	/* set cells */
	for (fc_r = 0; fc_r < fc_cont.nrows; fc_r++)
	{
		for (fc_c = 0; fc_c < fc_cont.ncolumns; fc_c++)
		{
			char	   *fc_cell;
			bool		fc_mustfree = false;
			bool		fc_translate;

			if (PQgetisnull(fc_result, fc_r, fc_c))
				fc_cell = fc_opt->nullPrint ? fc_opt->nullPrint : "";
			else
			{
				fc_cell = PQgetvalue(fc_result, fc_r, fc_c);
				if (fc_cont.aligns[fc_c] == 'r' && fc_opt->topt.numericLocale)
				{
					fc_cell = fc_format_numeric_locale(fc_cell);
					fc_mustfree = true;
				}
			}

			fc_translate = (fc_opt->translate_columns && fc_opt->translate_columns[fc_c]);
			printTableAddCell(&fc_cont, fc_cell, fc_translate, fc_mustfree);
		}
	}

	/* set footers */
	if (fc_opt->footers)
	{
		char	  **fc_footer;

		for (fc_footer = fc_opt->footers; *fc_footer; fc_footer++)
			printTableAddFooter(&fc_cont, *fc_footer);
	}

	printTable(&fc_cont, fc_fout, fc_is_pager, fc_flog);
	printTableCleanup(&fc_cont);
}

char column_type_alignment(Oid fc_ftype)
{
	char		fc_align;

	switch (fc_ftype)
	{
		case INT2OID:
		case INT4OID:
		case INT8OID:
		case FLOAT4OID:
		case FLOAT8OID:
		case NUMERICOID:
		case OIDOID:
		case XIDOID:
		case XID8OID:
		case CIDOID:
		case MONEYOID:
			fc_align = 'r';
			break;
		default:
			fc_align = 'l';
			break;
	}
	return fc_align;
}

void setDecimalLocale(void)
{
	struct lconv *fc_extlconv;

	fc_extlconv = localeconv();

	/* Don't accept an empty decimal_point string */
	if (*fc_extlconv->decimal_point)
		decimal_point = pg_strdup(fc_extlconv->decimal_point);
	else
		decimal_point = ".";	/* SQL output standard */

	/*
	 * Although the Open Group standard allows locales to supply more than one
	 * group width, we consider only the first one, and we ignore any attempt
	 * to suppress grouping by specifying CHAR_MAX.  As in the backend's
	 * cash.c, we must apply a range check to avoid being fooled by variant
	 * CHAR_MAX values.
	 */
	groupdigits = *fc_extlconv->grouping;
	if (groupdigits <= 0 || groupdigits > 6)
		groupdigits = 3;		/* most common */

	/* Don't accept an empty thousands_sep string, either */
	/* similar code exists in formatting.c */
	if (*fc_extlconv->thousands_sep)
		thousands_sep = pg_strdup(fc_extlconv->thousands_sep);
	/* Make sure thousands separator doesn't match decimal point symbol. */
	else if (strcmp(decimal_point, ",") != 0)
		thousands_sep = ",";
	else
		thousands_sep = ".";
}

/* get selected or default line style */
const printTextFormat *
get_line_style(const printTableOpt *fc_opt)
{
	/*
	 * Note: this function mainly exists to preserve the convention that a
	 * printTableOpt struct can be initialized to zeroes to get default
	 * behavior.
	 */
	if (fc_opt->line_style != NULL)
		return fc_opt->line_style;
	else
		return &pg_asciiformat;
}

void refresh_utf8format(const printTableOpt *fc_opt)
{
	printTextFormat *fc_popt = &pg_utf8format;

	const unicodeStyleBorderFormat *fc_border;
	const unicodeStyleRowFormat *fc_header;
	const unicodeStyleColumnFormat *fc_column;

	fc_popt->name = "unicode";

	fc_border = &unicode_style.border_style[fc_opt->unicode_border_linestyle];
	fc_header = &unicode_style.row_style[fc_opt->unicode_header_linestyle];
	fc_column = &unicode_style.column_style[fc_opt->unicode_column_linestyle];

	fc_popt->lrule[PRINT_RULE_TOP].hrule = fc_border->horizontal;
	fc_popt->lrule[PRINT_RULE_TOP].leftvrule = fc_border->down_and_right;
	fc_popt->lrule[PRINT_RULE_TOP].midvrule = fc_column->down_and_horizontal[fc_opt->unicode_border_linestyle];
	fc_popt->lrule[PRINT_RULE_TOP].rightvrule = fc_border->down_and_left;

	fc_popt->lrule[PRINT_RULE_MIDDLE].hrule = fc_header->horizontal;
	fc_popt->lrule[PRINT_RULE_MIDDLE].leftvrule = fc_header->vertical_and_right[fc_opt->unicode_border_linestyle];
	fc_popt->lrule[PRINT_RULE_MIDDLE].midvrule = fc_column->vertical_and_horizontal[fc_opt->unicode_header_linestyle];
	fc_popt->lrule[PRINT_RULE_MIDDLE].rightvrule = fc_header->vertical_and_left[fc_opt->unicode_border_linestyle];

	fc_popt->lrule[PRINT_RULE_BOTTOM].hrule = fc_border->horizontal;
	fc_popt->lrule[PRINT_RULE_BOTTOM].leftvrule = fc_border->up_and_right;
	fc_popt->lrule[PRINT_RULE_BOTTOM].midvrule = fc_column->up_and_horizontal[fc_opt->unicode_border_linestyle];
	fc_popt->lrule[PRINT_RULE_BOTTOM].rightvrule = fc_border->left_and_right;

	/* 不适用 */
	fc_popt->lrule[PRINT_RULE_DATA].hrule = "";
	fc_popt->lrule[PRINT_RULE_DATA].leftvrule = fc_border->vertical;
	fc_popt->lrule[PRINT_RULE_DATA].midvrule = fc_column->vertical;
	fc_popt->lrule[PRINT_RULE_DATA].rightvrule = fc_border->vertical;

	fc_popt->midvrule_nl = fc_column->vertical;
	fc_popt->midvrule_wrap = fc_column->vertical;
	fc_popt->midvrule_blank = fc_column->vertical;

	/* Same for all unicode today */
	fc_popt->header_nl_left = unicode_style.header_nl_left;
	fc_popt->header_nl_right = unicode_style.header_nl_right;
	fc_popt->nl_left = unicode_style.nl_left;
	fc_popt->nl_right = unicode_style.nl_right;
	fc_popt->wrap_left = unicode_style.wrap_left;
	fc_popt->wrap_right = unicode_style.wrap_right;
	fc_popt->wrap_right_border = unicode_style.wrap_right_border;
}

/*
 * Compute the byte distance to the end of the string or *target_width
 * display character positions, whichever comes first.  Update *target_width
 * to be the number of display character positions actually filled.
 */
static int fc_strlen_max_width(unsigned char *fc_str, int *fc_target_width, int fc_encoding)
{
	unsigned char *fc_start = fc_str;
	unsigned char *fc_end = fc_str + strlen((char *) fc_str);
	int			fc_curr_width = 0;

	while (fc_str < fc_end)
	{
		int			fc_char_width = PQdsplen((char *) fc_str, fc_encoding);

		/*
		 * If the display width of the new character causes the string to
		 * exceed its target width, skip it and return.  However, if this is
		 * the first character of the string (curr_width == 0), we have to
		 * accept it.
		 */
		if (*fc_target_width < fc_curr_width + fc_char_width && fc_curr_width != 0)
			break;

		fc_curr_width += fc_char_width;

		fc_str += PQmblen((char *) fc_str, fc_encoding);

		if (fc_str > fc_end)			/* Don't overrun invalid string */
			fc_str = fc_end;
	}

	*fc_target_width = fc_curr_width;

	return fc_str - fc_start;
}
